
bin/main.elf:     file format elf32-littlearm

Sections:
Idx Name          Size      VMA       LMA       File off  Algn
  0 .text         00001268  00000000  00000000  00010000  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  1 .text.arm_Init 00000138  00001268  00001268  00011268  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  2 .text._start  00000048  000013a0  000013a0  000113a0  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  3 .text.nmi_ISR 00000020  000013e8  000013e8  000113e8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  4 .text.hardFault_ISR 00000050  00001408  00001408  00011408  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  5 .text.memManage_ISR 00000020  00001458  00001458  00011458  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  6 .text.busFault_ISR 00000020  00001478  00001478  00011478  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  7 .text.usageFault_ISR 00000020  00001498  00001498  00011498  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  8 .text.svc_ISR 00000020  000014b8  000014b8  000114b8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  9 .text.debugMon_ISR 00000020  000014d8  000014d8  000114d8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 10 .text.pendSV_ISR 00000020  000014f8  000014f8  000114f8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 11 .text.wdt_ISR 00000020  00001518  00001518  00011518  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 12 .text.timer0_ISR 00000020  00001538  00001538  00011538  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 13 .text.timer1_ISR 00000020  00001558  00001558  00011558  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 14 .text.timer2_ISR 00000020  00001578  00001578  00011578  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 15 .text.timer3_ISR 00000020  00001598  00001598  00011598  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 16 .text.uart1_ISR 00000020  000015b8  000015b8  000115b8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 17 .text.uart2_ISR 00000020  000015d8  000015d8  000115d8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 18 .text.uart3_ISR 00000020  000015f8  000015f8  000115f8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 19 .text.pwm_ISR 00000020  00001618  00001618  00011618  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 20 .text.i2c0_ISR 00000020  00001638  00001638  00011638  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 21 .text.i2c1_ISR 00000020  00001658  00001658  00011658  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 22 .text.i2c2_ISR 00000020  00001678  00001678  00011678  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 23 .text.spi_ISR 00000020  00001698  00001698  00011698  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 24 .text.ssp0_ISR 00000020  000016b8  000016b8  000116b8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 25 .text.ssp1_ISR 00000020  000016d8  000016d8  000116d8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 26 .text.pll0_ISR 00000020  000016f8  000016f8  000116f8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 27 .text.rtc_ISR 00000020  00001718  00001718  00011718  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 28 .text.eint0_ISR 00000020  00001738  00001738  00011738  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 29 .text.eint1_ISR 00000020  00001758  00001758  00011758  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 30 .text.eint2_ISR 00000020  00001778  00001778  00011778  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 31 .text.eint3_ISR 00000020  00001798  00001798  00011798  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 32 .text.adc_ISR 00000020  000017b8  000017b8  000117b8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 33 .text.bod_ISR 00000020  000017d8  000017d8  000117d8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 34 .text.usbHost_ISR 00000020  000017f8  000017f8  000117f8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 35 .text.can_ISR 00000020  00001818  00001818  00011818  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 36 .text.dma_ISR 00000020  00001838  00001838  00011838  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 37 .text.i2s_ISR 00000020  00001858  00001858  00011858  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 38 .text.enet_ISR 00000020  00001878  00001878  00011878  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 39 .text.rit_ISR 00000020  00001898  00001898  00011898  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 40 .text.mcpwm_ISR 00000020  000018b8  000018b8  000118b8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 41 .text.qei_ISR 00000020  000018d8  000018d8  000118d8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 42 .text.pll1_ISR 00000020  000018f8  000018f8  000118f8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 43 .text.usbAct_ISR 00000020  00001918  00001918  00011918  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 44 .text.canAct_ISR 00000020  00001938  00001938  00011938  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 45 .text.uart4_ISR 00000020  00001958  00001958  00011958  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 46 .text.ssp2_ISR 00000020  00001978  00001978  00011978  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 47 .text.lcd_ISR 00000020  00001998  00001998  00011998  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 48 .text.gpio_ISR 00000020  000019b8  000019b8  000119b8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 49 .text.pwm0_ISR 00000020  000019d8  000019d8  000119d8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 50 .text.eeprom_ISR 00000020  000019f8  000019f8  000119f8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 51 .text.nvic_setPendingIRQ 0000001a  00001a18  00001a18  00011a18  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 52 .text.nvic_enableIRQ 00000004  00001a32  00001a32  00011a32  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 53 .text.nvic_clearPendingIRQ 00000018  00001a38  00001a38  00011a38  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 54 .text.nvic_setPriority 00000044  00001a50  00001a50  00011a50  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 55 .text.nvic_SetIntHandler 0000000c  00001a94  00001a94  00011a94  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 56 .text.systime_Init 0000005c  00001aa0  00001aa0  00011aa0  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 57 .text.systime_SetIntHandler 00000014  00001afc  00001afc  00011afc  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 58 .text.sysTick_ISR 00000064  00001b10  00001b10  00011b10  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 59 .text.delay   00000006  00001b74  00001b74  00011b74  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 60 .text.uart0_SetBaudrate 000000ec  00001b80  00001b80  00011b80  2**3
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 61 .text.uart0_Init 000000a8  00001c6c  00001c6c  00011c6c  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 62 .text.uart0_GetChar 00000044  00001d14  00001d14  00011d14  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 63 .text.uart0_PutChar 00000068  00001d58  00001d58  00011d58  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 64 .text.uart0_BasicPutChar 0000001c  00001dc0  00001dc0  00011dc0  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 65 .text.uart0_ISR 000000b4  00001ddc  00001ddc  00011ddc  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 66 .text.ssp1_SetClockFreq 00000030  00001e90  00001e90  00011e90  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 67 .text.spp1_SetMode 00000018  00001ec0  00001ec0  00011ec0  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 68 .text.ssp1_Init 00000064  00001ed8  00001ed8  00011ed8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 69 .text.ssp1_TransferByte 00000024  00001f3c  00001f3c  00011f3c  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 70 .text.showVicError 00000078  00001f60  00001f60  00011f60  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 71 .text.startup.main 000000b4  00001fd8  00001fd8  00011fd8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 72 .text.drawFrame 00000018  0000208c  0000208c  0001208c  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 73 .text.tft_BackLight 00000018  000020a4  000020a4  000120a4  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 74 .text.test_FillScreen 0000004c  000020bc  000020bc  000120bc  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 75 .text.test_FastLines 00000050  00002108  00002108  00012108  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 76 .text.test_Lines 00000128  00002158  00002158  00012158  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 77 .text.test_Circles 0000003e  00002280  00002280  00012280  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 78 .text.test_FilledCircles 00000040  000022be  000022be  000122be  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 79 .text.test_Triangles 00000056  000022fe  000022fe  000122fe  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 80 .text.test_FilledTriangles 00000090  00002354  00002354  00012354  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 81 .text.test_RoundRects 0000006c  000023e4  000023e4  000123e4  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 82 .text.test_FilledRoundRects 0000006a  00002450  00002450  00012450  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 83 .text.test_Rects 00000058  000024ba  000024ba  000124ba  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 84 .text.test_FilledRects 00000072  00002512  00002512  00012512  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 85 .text.test_Buttons 000000b8  00002584  00002584  00012584  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 86 .text.test_Printf 000000a8  0000263c  0000263c  0001263c  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 87 .text.test_Text 0000002c  000026e4  000026e4  000126e4  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 88 .text.onKeyDown 00000034  00002710  00002710  00012710  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 89 .text.onKeyPress 00000018  00002744  00002744  00012744  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 90 .text.onKeyUp 00000018  0000275c  0000275c  0001275c  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 91 .text.relay_Init 00000028  00002774  00002774  00012774  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 92 .text.relay_Set 00000030  0000279c  0000279c  0001279c  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 93 .text.relay_Tick 00000068  000027cc  000027cc  000127cc  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 94 .text.app_Init 00000040  00002834  00002834  00012834  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 95 .text.app_Tick 000000a4  00002874  00002874  00012874  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 96 .text.app_Process 00000002  00002918  00002918  00012918  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 97 .text.prompt_ClearTicks 00000010  0000291c  0000291c  0001291c  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 98 .text.prompt_STS 0000006c  0000292c  0000292c  0001292c  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 99 .text.prompt_Tests 000000a4  00002998  00002998  00012998  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
100 .text.prompt_Init 0000000a  00002a3c  00002a3c  00012a3c  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
101 .text.prompt_Reset 0000000a  00002a46  00002a46  00012a46  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
102 .text.prompt_LedB 00000020  00002a50  00002a50  00012a50  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
103 .text.prompt_Dump 0000008a  00002a70  00002a70  00012a70  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
104 .text.prompt_Beep 0000001a  00002afa  00002afa  00012afa  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
105 .text.prompt_Relay 00000068  00002b14  00002b14  00012b14  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
106 .text.prompt_Process 00000088  00002b7c  00002b7c  00012b7c  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
107 .text.print_putchar 00000074  00002c04  00002c04  00012c04  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
108 .text.print_fill 0000001a  00002c78  00002c78  00012c78  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
109 .text.print_int 00000058  00002c92  00002c92  00012c92  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
110 .text.print_long 0000004e  00002cea  00002cea  00012cea  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
111 .text.print_float 000000b4  00002d38  00002d38  00012d38  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
112 .text.rprintf_RegisterDev 00000030  00002dec  00002dec  00012dec  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
113 .text.lputchar_RegisterDev 0000000c  00002e1c  00002e1c  00012e1c  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
114 .text.ldebug_RegisterDev 0000000c  00002e28  00002e28  00012e28  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
115 .text.lgetchar_RegisterDev 0000000c  00002e34  00002e34  00012e34  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
116 .text.doprint 00000378  00002e40  00002e40  00012e40  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
117 .text.lgetchar 0000000c  000031b8  000031b8  000131b8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
118 .text.rprintf 0000002a  000031c4  000031c4  000131c4  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
119 .text.buffer_Init 0000000c  000031ee  000031ee  000131ee  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
120 .text.buffer_GetFromFront 00000044  000031fa  000031fa  000131fa  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
121 .text.buffer_AddToEnd 0000003a  0000323e  0000323e  0001323e  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
122 .text.buffer_IsEmpty 0000000c  00003278  00003278  00013278  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
123 .text.put_dump16 00000094  00003284  00003284  00013284  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
124 .text.xatoi   000000a8  00003318  00003318  00013318  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
125 .text.ledError_Init 00000018  000033c0  000033c0  000133c0  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
126 .text.ledError_Tick 00000090  000033d8  000033d8  000133d8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
127 .text.gKey_Init 00000024  00003468  00003468  00013468  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
128 .text.gKey_Tick 00000014  0000348c  0000348c  0001348c  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
129 .text.gKey_Process 000000a8  000034a0  000034a0  000134a0  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
130 .text.beep_SetType 00000088  00003548  00003548  00013548  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
131 .text.beep_Init 0000002c  000035d0  000035d0  000135d0  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
132 .text.beep_Play 00000024  000035fc  000035fc  000135fc  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
133 .text.beep_Tick 0000008c  00003620  00003620  00013620  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
134 .text.cli_GetLine 000000f4  000036ac  000036ac  000136ac  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
135 .text.cli_Help 00000098  000037a0  000037a0  000137a0  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
136 .text.cli_ArgsParse 000000f0  00003838  00003838  00013838  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
137 .text.cli_ArgsDispatch 000000a0  00003928  00003928  00013928  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
138 .text.tft_Reset 00000038  000039c8  000039c8  000139c8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
139 .text.tft_WriteCommand 00000024  00003a00  00003a00  00013a00  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
140 .text.tft_WriteData 00000024  00003a24  00003a24  00013a24  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
141 .text.tft_Init 0000023c  00003a48  00003a48  00013a48  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
142 .text.tft_SetAddrWindow 00000050  00003c84  00003c84  00013c84  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
143 .text.tft_DrawPixel 0000005c  00003cd4  00003cd4  00013cd4  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
144 .text.tft_DrawFastVLine 00000070  00003d30  00003d30  00013d30  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
145 .text.tft_DrawFastHLine 00000070  00003da0  00003da0  00013da0  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
146 .text.tft_FillRect 0000009c  00003e10  00003e10  00013e10  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
147 .text.tft_FillScreen 00000028  00003eac  00003eac  00013eac  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
148 .text.tft_Color565 00000014  00003ed4  00003ed4  00013ed4  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
149 .text.tft_SetRotation 00000050  00003ee8  00003ee8  00013ee8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
150 .text.tft_Width 0000000c  00003f38  00003f38  00013f38  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
151 .text.tft_Height 0000000c  00003f44  00003f44  00013f44  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
152 .text.gfx_Init 00000058  00003f50  00003f50  00013f50  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
153 .text.gfx_SetRotation 00000038  00003fa8  00003fa8  00013fa8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
154 .text.gfx_DrawLine 00000098  00003fe0  00003fe0  00013fe0  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
155 .text.gfx_FillRect 0000002a  00004078  00004078  00014078  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
156 .text.gfx_FillScreen 00000024  000040a4  000040a4  000140a4  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
157 .text.gfx_DrawRect 0000005c  000040c8  000040c8  000140c8  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
158 .text.gfx_DrawTriangle 0000003a  00004124  00004124  00014124  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
159 .text.gfx_FillTriangle 00000162  0000415e  0000415e  0001415e  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
160 .text.gfx_DrawCircle 00000132  000042c0  000042c0  000142c0  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
161 .text.gfx_DrawCircleHelper 00000130  000043f2  000043f2  000143f2  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
162 .text.gfx_FillCircleHelper 000000f6  00004522  00004522  00014522  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
163 .text.gfx_FillCircle 00000034  00004618  00004618  00014618  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
164 .text.gfx_DrawRoundRect 000000ec  0000464c  0000464c  0001464c  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
165 .text.gfx_FillRoundRect 0000005e  00004738  00004738  00014738  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
166 .text.gfx_SetCursor 00000014  00004798  00004798  00014798  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
167 .text.gfx_SetTextSize 00000010  000047ac  000047ac  000147ac  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
168 .text.gfx_SetTextColor 0000000c  000047bc  000047bc  000147bc  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
169 .text.gfx_DrawChar 000000f8  000047c8  000047c8  000147c8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
170 .text.gfx_PutChar 000000bc  000048c0  000048c0  000148c0  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
171 .text.gfx_SetFont 0000000c  0000497c  0000497c  0001497c  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
172 .text.gfx_printfInit 00000014  00004988  00004988  00014988  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
173 .text.gfx_printf 00000044  0000499c  0000499c  0001499c  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
174 .text.__get_current_locale 00000018  000049e0  000049e0  000149e0  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
175 .text.__locale_ctype_ptr 00000014  000049f8  000049f8  000149f8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
176 .text.__ascii_mbtowc 0000002c  00004a0c  00004a0c  00014a0c  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
177 .text.memset  0000009c  00004a38  00004a38  00014a38  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
178 .text.strlen  0000005c  00004ad4  00004ad4  00014ad4  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
179 .text.__ascii_wctomb 0000001c  00004b30  00004b30  00014b30  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
180 .rodata       00005c81  00004b4c  00004b4c  00014b4c  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, DATA
181 .data         000005dc  10000000  0000a7d0  00020000  2**3
                  CONTENTS, ALLOC, LOAD, DATA
182 .bss          00000020  100005dc  0000adac  000205dc  2**2
                  ALLOC
183 .bss.vicerr_Functions 00000004  100005fc  0000adcc  000205dc  2**2
                  ALLOC
184 .bss.countTicksLed 00000004  10000600  0000add0  000205dc  2**2
                  ALLOC
185 .bss.countTicks_ms 00000004  10000604  0000add4  000205dc  2**2
                  ALLOC
186 .bss.callfuncTime 00000004  10000608  0000add8  000205dc  2**2
                  ALLOC
187 .bss.systime_IntFunctions 00000004  1000060c  0000addc  000205dc  2**2
                  ALLOC
188 .bss.u0_data_tx 00000096  10000610  0000ade0  000205dc  2**0
                  ALLOC
189 .bss.u0_tx_running 00000001  100006a6  0000ae76  000205dc  2**0
                  ALLOC
190 .bss.u0_overflow_rx 00000002  100006a8  0000ae78  000205dc  2**1
                  ALLOC
191 .bss.u0_buf_rx 0000000c  100006ac  0000ae7c  000205dc  2**2
                  ALLOC
192 .bss.u0_buf_tx 0000000c  100006b8  0000ae88  000205dc  2**2
                  ALLOC
193 .bss.u0_data_rx 00000096  100006c4  0000ae94  000205dc  2**0
                  ALLOC
194 .bss.x.5107   00000004  1000075c  0000af2c  000205dc  2**2
                  ALLOC
195 .bss.timeReadKey.5236 00000004  10000760  0000af30  000205dc  2**2
                  ALLOC
196 .bss.bufKey.5237 0000000c  10000764  0000af34  000205dc  2**2
                  ALLOC
197 .bss.idx.5238 00000004  10000770  0000af40  000205dc  2**2
                  ALLOC
198 .bss.argc_prompt 00000004  10000774  0000af44  000205dc  2**2
                  ALLOC
199 .bss.result_prompt 00000004  10000778  0000af48  000205dc  2**2
                  ALLOC
200 .bss.argv_prompt 00000028  1000077c  0000af4c  000205dc  2**2
                  ALLOC
201 .bss.buffer_prompt 00000028  100007a4  0000af74  000205dc  2**0
                  ALLOC
202 .bss.dev1_putc 00000004  100007cc  0000af9c  000205dc  2**2
                  ALLOC
203 .bss.stdio_putc 00000004  100007d0  0000afa0  000205dc  2**2
                  ALLOC
204 .bss.putcharfunc.4737 00000004  100007d4  0000afa4  000205dc  2**2
                  ALLOC
205 .bss.dev3_putc 00000004  100007d8  0000afa8  000205dc  2**2
                  ALLOC
206 .bss.dev2_putc 00000004  100007dc  0000afac  000205dc  2**2
                  ALLOC
207 .bss.stdio_getc 00000004  100007e0  0000afb0  000205dc  2**2
                  ALLOC
208 .bss.dev4_putc 00000004  100007e4  0000afb4  000205dc  2**2
                  ALLOC
209 .bss.debug_putc 00000004  100007e8  0000afb8  000205dc  2**2
                  ALLOC
210 .bss.err_putc 00000004  100007ec  0000afbc  000205dc  2**2
                  ALLOC
211 .bss.count1.4249 00000004  100007f0  0000afc0  000205dc  2**2
                  ALLOC
212 .bss.error    00000004  100007f4  0000afc4  000205dc  2**2
                  ALLOC
213 .bss.ledBlink 00000004  100007f8  0000afc8  000205dc  2**2
                  ALLOC
214 .bss.ff.4251  00000004  100007fc  0000afcc  000205dc  2**2
                  ALLOC
215 .bss.count2.4250 00000004  10000800  0000afd0  000205dc  2**2
                  ALLOC
216 .bss.nTimes.4252 00000004  10000804  0000afd4  000205dc  2**2
                  ALLOC
217 .bss.repeat.4250 00000004  10000808  0000afd8  000205dc  2**2
                  ALLOC
218 .bss.estado.4249 00000001  1000080c  0000afdc  000205dc  2**0
                  ALLOC
219 .bss.onKeyUp  00000004  10000810  0000afe0  000205dc  2**2
                  ALLOC
220 .bss.timeRepeat 00000004  10000814  0000afe4  000205dc  2**2
                  ALLOC
221 .bss.keynow.4248 00000001  10000818  0000afe8  000205dc  2**0
                  ALLOC
222 .bss.onKeyDown 00000004  1000081c  0000afec  000205dc  2**2
                  ALLOC
223 .bss.onKeyPress 00000004  10000820  0000aff0  000205dc  2**2
                  ALLOC
224 .bss.beep     00000030  10000824  0000aff4  000205dc  2**2
                  ALLOC
225 .bss.cmd_list_active 00000004  10000854  0000b024  000205dc  2**2
                  ALLOC
226 .bss.p        00000004  10000858  0000b028  000205dc  2**2
                  ALLOC
227 .bss.c        00000001  1000085c  0000b02c  000205dc  2**0
                  ALLOC
228 .bss._width   00000004  10000860  0000b030  000205dc  2**2
                  ALLOC
229 .bss.textcolor 00000004  10000864  0000b034  000205dc  2**2
                  ALLOC
230 .bss.wrap     00000004  10000868  0000b038  000205dc  2**2
                  ALLOC
231 .bss.textsize 00000004  1000086c  0000b03c  000205dc  2**2
                  ALLOC
232 .bss.devicePrintf 00000004  10000870  0000b040  000205dc  2**2
                  ALLOC
233 .bss._height  00000004  10000874  0000b044  000205dc  2**2
                  ALLOC
234 .bss.cursor_x 00000004  10000878  0000b048  000205dc  2**2
                  ALLOC
235 .bss.cursor_y 00000004  1000087c  0000b04c  000205dc  2**2
                  ALLOC
236 .bss.rotation 00000004  10000880  0000b050  000205dc  2**2
                  ALLOC
237 .comment      0000006e  00000000  00000000  000205dc  2**0
                  CONTENTS, READONLY
238 .ARM.attributes 00000031  00000000  00000000  0002064a  2**0
                  CONTENTS, READONLY
239 .debug_aranges 000008e0  00000000  00000000  0002067b  2**0
                  CONTENTS, READONLY, DEBUGGING
240 .debug_info   00009441  00000000  00000000  00020f5b  2**0
                  CONTENTS, READONLY, DEBUGGING
241 .debug_abbrev 0000218d  00000000  00000000  0002a39c  2**0
                  CONTENTS, READONLY, DEBUGGING
242 .debug_line   00002ac7  00000000  00000000  0002c529  2**0
                  CONTENTS, READONLY, DEBUGGING
243 .debug_frame  00001d04  00000000  00000000  0002eff0  2**2
                  CONTENTS, READONLY, DEBUGGING
244 .debug_str    00001799  00000000  00000000  00030cf4  2**0
                  CONTENTS, READONLY, DEBUGGING
245 .debug_loc    0000631d  00000000  00000000  0003248d  2**0
                  CONTENTS, READONLY, DEBUGGING
246 .debug_ranges 00000a90  00000000  00000000  000387aa  2**0
                  CONTENTS, READONLY, DEBUGGING

Disassembly of section .text:

00000000 <gVectors>:
       0:	00 40 00 10 a1 13 00 00 e9 13 00 00 09 14 00 00     .@..............
      10:	59 14 00 00 79 14 00 00 99 14 00 00 00 00 00 00     Y...y...........
	...
      2c:	b9 14 00 00 d9 14 00 00 00 00 00 00 f9 14 00 00     ................
      3c:	11 1b 00 00 19 15 00 00 39 15 00 00 59 15 00 00     ........9...Y...
      4c:	79 15 00 00 99 15 00 00 dd 1d 00 00 b9 15 00 00     y...............
      5c:	d9 15 00 00 f9 15 00 00 19 16 00 00 39 16 00 00     ............9...
      6c:	59 16 00 00 79 16 00 00 99 16 00 00 b9 16 00 00     Y...y...........
      7c:	d9 16 00 00 f9 16 00 00 19 17 00 00 39 17 00 00     ............9...
      8c:	59 17 00 00 79 17 00 00 99 17 00 00 b9 17 00 00     Y...y...........
      9c:	d9 17 00 00 f9 17 00 00 19 18 00 00 39 18 00 00     ............9...
      ac:	59 18 00 00 79 18 00 00 99 18 00 00 b9 18 00 00     Y...y...........
      bc:	d9 18 00 00 f9 18 00 00 19 19 00 00 39 19 00 00     ............9...
      cc:	59 19 00 00 79 19 00 00 99 19 00 00 b9 19 00 00     Y...y...........
      dc:	d9 19 00 00 f9 19 00 00 00 00 00 00 00 00 00 00     ................
	...

000002fc <__aeabi_drsub>:
     2fc:	f081 4100 	eor.w	r1, r1, #2147483648	; 0x80000000
     300:	e002      	b.n	308 <__adddf3>
     302:	bf00      	nop

00000304 <__aeabi_dsub>:
     304:	f083 4300 	eor.w	r3, r3, #2147483648	; 0x80000000

00000308 <__adddf3>:
     308:	b530      	push	{r4, r5, lr}
     30a:	ea4f 0441 	mov.w	r4, r1, lsl #1
     30e:	ea4f 0543 	mov.w	r5, r3, lsl #1
     312:	ea94 0f05 	teq	r4, r5
     316:	bf08      	it	eq
     318:	ea90 0f02 	teqeq	r0, r2
     31c:	bf1f      	itttt	ne
     31e:	ea54 0c00 	orrsne.w	ip, r4, r0
     322:	ea55 0c02 	orrsne.w	ip, r5, r2
     326:	ea7f 5c64 	mvnsne.w	ip, r4, asr #21
     32a:	ea7f 5c65 	mvnsne.w	ip, r5, asr #21
     32e:	f000 80e2 	beq.w	4f6 <__adddf3+0x1ee>
     332:	ea4f 5454 	mov.w	r4, r4, lsr #21
     336:	ebd4 5555 	rsbs	r5, r4, r5, lsr #21
     33a:	bfb8      	it	lt
     33c:	426d      	neglt	r5, r5
     33e:	dd0c      	ble.n	35a <__adddf3+0x52>
     340:	442c      	add	r4, r5
     342:	ea80 0202 	eor.w	r2, r0, r2
     346:	ea81 0303 	eor.w	r3, r1, r3
     34a:	ea82 0000 	eor.w	r0, r2, r0
     34e:	ea83 0101 	eor.w	r1, r3, r1
     352:	ea80 0202 	eor.w	r2, r0, r2
     356:	ea81 0303 	eor.w	r3, r1, r3
     35a:	2d36      	cmp	r5, #54	; 0x36
     35c:	bf88      	it	hi
     35e:	bd30      	pophi	{r4, r5, pc}
     360:	f011 4f00 	tst.w	r1, #2147483648	; 0x80000000
     364:	ea4f 3101 	mov.w	r1, r1, lsl #12
     368:	f44f 1c80 	mov.w	ip, #1048576	; 0x100000
     36c:	ea4c 3111 	orr.w	r1, ip, r1, lsr #12
     370:	d002      	beq.n	378 <__adddf3+0x70>
     372:	4240      	negs	r0, r0
     374:	eb61 0141 	sbc.w	r1, r1, r1, lsl #1
     378:	f013 4f00 	tst.w	r3, #2147483648	; 0x80000000
     37c:	ea4f 3303 	mov.w	r3, r3, lsl #12
     380:	ea4c 3313 	orr.w	r3, ip, r3, lsr #12
     384:	d002      	beq.n	38c <__adddf3+0x84>
     386:	4252      	negs	r2, r2
     388:	eb63 0343 	sbc.w	r3, r3, r3, lsl #1
     38c:	ea94 0f05 	teq	r4, r5
     390:	f000 80a7 	beq.w	4e2 <__adddf3+0x1da>
     394:	f1a4 0401 	sub.w	r4, r4, #1
     398:	f1d5 0e20 	rsbs	lr, r5, #32
     39c:	db0d      	blt.n	3ba <__adddf3+0xb2>
     39e:	fa02 fc0e 	lsl.w	ip, r2, lr
     3a2:	fa22 f205 	lsr.w	r2, r2, r5
     3a6:	1880      	adds	r0, r0, r2
     3a8:	f141 0100 	adc.w	r1, r1, #0
     3ac:	fa03 f20e 	lsl.w	r2, r3, lr
     3b0:	1880      	adds	r0, r0, r2
     3b2:	fa43 f305 	asr.w	r3, r3, r5
     3b6:	4159      	adcs	r1, r3
     3b8:	e00e      	b.n	3d8 <__adddf3+0xd0>
     3ba:	f1a5 0520 	sub.w	r5, r5, #32
     3be:	f10e 0e20 	add.w	lr, lr, #32
     3c2:	2a01      	cmp	r2, #1
     3c4:	fa03 fc0e 	lsl.w	ip, r3, lr
     3c8:	bf28      	it	cs
     3ca:	f04c 0c02 	orrcs.w	ip, ip, #2
     3ce:	fa43 f305 	asr.w	r3, r3, r5
     3d2:	18c0      	adds	r0, r0, r3
     3d4:	eb51 71e3 	adcs.w	r1, r1, r3, asr #31
     3d8:	f001 4500 	and.w	r5, r1, #2147483648	; 0x80000000
     3dc:	d507      	bpl.n	3ee <__adddf3+0xe6>
     3de:	f04f 0e00 	mov.w	lr, #0
     3e2:	f1dc 0c00 	rsbs	ip, ip, #0
     3e6:	eb7e 0000 	sbcs.w	r0, lr, r0
     3ea:	eb6e 0101 	sbc.w	r1, lr, r1
     3ee:	f5b1 1f80 	cmp.w	r1, #1048576	; 0x100000
     3f2:	d31b      	bcc.n	42c <__adddf3+0x124>
     3f4:	f5b1 1f00 	cmp.w	r1, #2097152	; 0x200000
     3f8:	d30c      	bcc.n	414 <__adddf3+0x10c>
     3fa:	0849      	lsrs	r1, r1, #1
     3fc:	ea5f 0030 	movs.w	r0, r0, rrx
     400:	ea4f 0c3c 	mov.w	ip, ip, rrx
     404:	f104 0401 	add.w	r4, r4, #1
     408:	ea4f 5244 	mov.w	r2, r4, lsl #21
     40c:	f512 0f80 	cmn.w	r2, #4194304	; 0x400000
     410:	f080 809a 	bcs.w	548 <__adddf3+0x240>
     414:	f1bc 4f00 	cmp.w	ip, #2147483648	; 0x80000000
     418:	bf08      	it	eq
     41a:	ea5f 0c50 	movseq.w	ip, r0, lsr #1
     41e:	f150 0000 	adcs.w	r0, r0, #0
     422:	eb41 5104 	adc.w	r1, r1, r4, lsl #20
     426:	ea41 0105 	orr.w	r1, r1, r5
     42a:	bd30      	pop	{r4, r5, pc}
     42c:	ea5f 0c4c 	movs.w	ip, ip, lsl #1
     430:	4140      	adcs	r0, r0
     432:	eb41 0101 	adc.w	r1, r1, r1
     436:	f411 1f80 	tst.w	r1, #1048576	; 0x100000
     43a:	f1a4 0401 	sub.w	r4, r4, #1
     43e:	d1e9      	bne.n	414 <__adddf3+0x10c>
     440:	f091 0f00 	teq	r1, #0
     444:	bf04      	itt	eq
     446:	4601      	moveq	r1, r0
     448:	2000      	moveq	r0, #0
     44a:	fab1 f381 	clz	r3, r1
     44e:	bf08      	it	eq
     450:	3320      	addeq	r3, #32
     452:	f1a3 030b 	sub.w	r3, r3, #11
     456:	f1b3 0220 	subs.w	r2, r3, #32
     45a:	da0c      	bge.n	476 <__adddf3+0x16e>
     45c:	320c      	adds	r2, #12
     45e:	dd08      	ble.n	472 <__adddf3+0x16a>
     460:	f102 0c14 	add.w	ip, r2, #20
     464:	f1c2 020c 	rsb	r2, r2, #12
     468:	fa01 f00c 	lsl.w	r0, r1, ip
     46c:	fa21 f102 	lsr.w	r1, r1, r2
     470:	e00c      	b.n	48c <__adddf3+0x184>
     472:	f102 0214 	add.w	r2, r2, #20
     476:	bfd8      	it	le
     478:	f1c2 0c20 	rsble	ip, r2, #32
     47c:	fa01 f102 	lsl.w	r1, r1, r2
     480:	fa20 fc0c 	lsr.w	ip, r0, ip
     484:	bfdc      	itt	le
     486:	ea41 010c 	orrle.w	r1, r1, ip
     48a:	4090      	lslle	r0, r2
     48c:	1ae4      	subs	r4, r4, r3
     48e:	bfa2      	ittt	ge
     490:	eb01 5104 	addge.w	r1, r1, r4, lsl #20
     494:	4329      	orrge	r1, r5
     496:	bd30      	popge	{r4, r5, pc}
     498:	ea6f 0404 	mvn.w	r4, r4
     49c:	3c1f      	subs	r4, #31
     49e:	da1c      	bge.n	4da <__adddf3+0x1d2>
     4a0:	340c      	adds	r4, #12
     4a2:	dc0e      	bgt.n	4c2 <__adddf3+0x1ba>
     4a4:	f104 0414 	add.w	r4, r4, #20
     4a8:	f1c4 0220 	rsb	r2, r4, #32
     4ac:	fa20 f004 	lsr.w	r0, r0, r4
     4b0:	fa01 f302 	lsl.w	r3, r1, r2
     4b4:	ea40 0003 	orr.w	r0, r0, r3
     4b8:	fa21 f304 	lsr.w	r3, r1, r4
     4bc:	ea45 0103 	orr.w	r1, r5, r3
     4c0:	bd30      	pop	{r4, r5, pc}
     4c2:	f1c4 040c 	rsb	r4, r4, #12
     4c6:	f1c4 0220 	rsb	r2, r4, #32
     4ca:	fa20 f002 	lsr.w	r0, r0, r2
     4ce:	fa01 f304 	lsl.w	r3, r1, r4
     4d2:	ea40 0003 	orr.w	r0, r0, r3
     4d6:	4629      	mov	r1, r5
     4d8:	bd30      	pop	{r4, r5, pc}
     4da:	fa21 f004 	lsr.w	r0, r1, r4
     4de:	4629      	mov	r1, r5
     4e0:	bd30      	pop	{r4, r5, pc}
     4e2:	f094 0f00 	teq	r4, #0
     4e6:	f483 1380 	eor.w	r3, r3, #1048576	; 0x100000
     4ea:	bf06      	itte	eq
     4ec:	f481 1180 	eoreq.w	r1, r1, #1048576	; 0x100000
     4f0:	3401      	addeq	r4, #1
     4f2:	3d01      	subne	r5, #1
     4f4:	e74e      	b.n	394 <__adddf3+0x8c>
     4f6:	ea7f 5c64 	mvns.w	ip, r4, asr #21
     4fa:	bf18      	it	ne
     4fc:	ea7f 5c65 	mvnsne.w	ip, r5, asr #21
     500:	d029      	beq.n	556 <__adddf3+0x24e>
     502:	ea94 0f05 	teq	r4, r5
     506:	bf08      	it	eq
     508:	ea90 0f02 	teqeq	r0, r2
     50c:	d005      	beq.n	51a <__adddf3+0x212>
     50e:	ea54 0c00 	orrs.w	ip, r4, r0
     512:	bf04      	itt	eq
     514:	4619      	moveq	r1, r3
     516:	4610      	moveq	r0, r2
     518:	bd30      	pop	{r4, r5, pc}
     51a:	ea91 0f03 	teq	r1, r3
     51e:	bf1e      	ittt	ne
     520:	2100      	movne	r1, #0
     522:	2000      	movne	r0, #0
     524:	bd30      	popne	{r4, r5, pc}
     526:	ea5f 5c54 	movs.w	ip, r4, lsr #21
     52a:	d105      	bne.n	538 <__adddf3+0x230>
     52c:	0040      	lsls	r0, r0, #1
     52e:	4149      	adcs	r1, r1
     530:	bf28      	it	cs
     532:	f041 4100 	orrcs.w	r1, r1, #2147483648	; 0x80000000
     536:	bd30      	pop	{r4, r5, pc}
     538:	f514 0480 	adds.w	r4, r4, #4194304	; 0x400000
     53c:	bf3c      	itt	cc
     53e:	f501 1180 	addcc.w	r1, r1, #1048576	; 0x100000
     542:	bd30      	popcc	{r4, r5, pc}
     544:	f001 4500 	and.w	r5, r1, #2147483648	; 0x80000000
     548:	f045 41fe 	orr.w	r1, r5, #2130706432	; 0x7f000000
     54c:	f441 0170 	orr.w	r1, r1, #15728640	; 0xf00000
     550:	f04f 0000 	mov.w	r0, #0
     554:	bd30      	pop	{r4, r5, pc}
     556:	ea7f 5c64 	mvns.w	ip, r4, asr #21
     55a:	bf1a      	itte	ne
     55c:	4619      	movne	r1, r3
     55e:	4610      	movne	r0, r2
     560:	ea7f 5c65 	mvnseq.w	ip, r5, asr #21
     564:	bf1c      	itt	ne
     566:	460b      	movne	r3, r1
     568:	4602      	movne	r2, r0
     56a:	ea50 3401 	orrs.w	r4, r0, r1, lsl #12
     56e:	bf06      	itte	eq
     570:	ea52 3503 	orrseq.w	r5, r2, r3, lsl #12
     574:	ea91 0f03 	teqeq	r1, r3
     578:	f441 2100 	orrne.w	r1, r1, #524288	; 0x80000
     57c:	bd30      	pop	{r4, r5, pc}
     57e:	bf00      	nop

00000580 <__aeabi_ui2d>:
     580:	f090 0f00 	teq	r0, #0
     584:	bf04      	itt	eq
     586:	2100      	moveq	r1, #0
     588:	4770      	bxeq	lr
     58a:	b530      	push	{r4, r5, lr}
     58c:	f44f 6480 	mov.w	r4, #1024	; 0x400
     590:	f104 0432 	add.w	r4, r4, #50	; 0x32
     594:	f04f 0500 	mov.w	r5, #0
     598:	f04f 0100 	mov.w	r1, #0
     59c:	e750      	b.n	440 <__adddf3+0x138>
     59e:	bf00      	nop

000005a0 <__aeabi_i2d>:
     5a0:	f090 0f00 	teq	r0, #0
     5a4:	bf04      	itt	eq
     5a6:	2100      	moveq	r1, #0
     5a8:	4770      	bxeq	lr
     5aa:	b530      	push	{r4, r5, lr}
     5ac:	f44f 6480 	mov.w	r4, #1024	; 0x400
     5b0:	f104 0432 	add.w	r4, r4, #50	; 0x32
     5b4:	f010 4500 	ands.w	r5, r0, #2147483648	; 0x80000000
     5b8:	bf48      	it	mi
     5ba:	4240      	negmi	r0, r0
     5bc:	f04f 0100 	mov.w	r1, #0
     5c0:	e73e      	b.n	440 <__adddf3+0x138>
     5c2:	bf00      	nop

000005c4 <__aeabi_f2d>:
     5c4:	0042      	lsls	r2, r0, #1
     5c6:	ea4f 01e2 	mov.w	r1, r2, asr #3
     5ca:	ea4f 0131 	mov.w	r1, r1, rrx
     5ce:	ea4f 7002 	mov.w	r0, r2, lsl #28
     5d2:	bf1f      	itttt	ne
     5d4:	f012 437f 	andsne.w	r3, r2, #4278190080	; 0xff000000
     5d8:	f093 4f7f 	teqne	r3, #4278190080	; 0xff000000
     5dc:	f081 5160 	eorne.w	r1, r1, #939524096	; 0x38000000
     5e0:	4770      	bxne	lr
     5e2:	f092 0f00 	teq	r2, #0
     5e6:	bf14      	ite	ne
     5e8:	f093 4f7f 	teqne	r3, #4278190080	; 0xff000000
     5ec:	4770      	bxeq	lr
     5ee:	b530      	push	{r4, r5, lr}
     5f0:	f44f 7460 	mov.w	r4, #896	; 0x380
     5f4:	f001 4500 	and.w	r5, r1, #2147483648	; 0x80000000
     5f8:	f021 4100 	bic.w	r1, r1, #2147483648	; 0x80000000
     5fc:	e720      	b.n	440 <__adddf3+0x138>
     5fe:	bf00      	nop

00000600 <__aeabi_ul2d>:
     600:	ea50 0201 	orrs.w	r2, r0, r1
     604:	bf08      	it	eq
     606:	4770      	bxeq	lr
     608:	b530      	push	{r4, r5, lr}
     60a:	f04f 0500 	mov.w	r5, #0
     60e:	e00a      	b.n	626 <__aeabi_l2d+0x16>

00000610 <__aeabi_l2d>:
     610:	ea50 0201 	orrs.w	r2, r0, r1
     614:	bf08      	it	eq
     616:	4770      	bxeq	lr
     618:	b530      	push	{r4, r5, lr}
     61a:	f011 4500 	ands.w	r5, r1, #2147483648	; 0x80000000
     61e:	d502      	bpl.n	626 <__aeabi_l2d+0x16>
     620:	4240      	negs	r0, r0
     622:	eb61 0141 	sbc.w	r1, r1, r1, lsl #1
     626:	f44f 6480 	mov.w	r4, #1024	; 0x400
     62a:	f104 0432 	add.w	r4, r4, #50	; 0x32
     62e:	ea5f 5c91 	movs.w	ip, r1, lsr #22
     632:	f43f aedc 	beq.w	3ee <__adddf3+0xe6>
     636:	f04f 0203 	mov.w	r2, #3
     63a:	ea5f 0cdc 	movs.w	ip, ip, lsr #3
     63e:	bf18      	it	ne
     640:	3203      	addne	r2, #3
     642:	ea5f 0cdc 	movs.w	ip, ip, lsr #3
     646:	bf18      	it	ne
     648:	3203      	addne	r2, #3
     64a:	eb02 02dc 	add.w	r2, r2, ip, lsr #3
     64e:	f1c2 0320 	rsb	r3, r2, #32
     652:	fa00 fc03 	lsl.w	ip, r0, r3
     656:	fa20 f002 	lsr.w	r0, r0, r2
     65a:	fa01 fe03 	lsl.w	lr, r1, r3
     65e:	ea40 000e 	orr.w	r0, r0, lr
     662:	fa21 f102 	lsr.w	r1, r1, r2
     666:	4414      	add	r4, r2
     668:	e6c1      	b.n	3ee <__adddf3+0xe6>
     66a:	bf00      	nop

0000066c <__aeabi_dmul>:
     66c:	b570      	push	{r4, r5, r6, lr}
     66e:	f04f 0cff 	mov.w	ip, #255	; 0xff
     672:	f44c 6ce0 	orr.w	ip, ip, #1792	; 0x700
     676:	ea1c 5411 	ands.w	r4, ip, r1, lsr #20
     67a:	bf1d      	ittte	ne
     67c:	ea1c 5513 	andsne.w	r5, ip, r3, lsr #20
     680:	ea94 0f0c 	teqne	r4, ip
     684:	ea95 0f0c 	teqne	r5, ip
     688:	f000 f8de 	bleq	848 <__aeabi_dmul+0x1dc>
     68c:	442c      	add	r4, r5
     68e:	ea81 0603 	eor.w	r6, r1, r3
     692:	ea21 514c 	bic.w	r1, r1, ip, lsl #21
     696:	ea23 534c 	bic.w	r3, r3, ip, lsl #21
     69a:	ea50 3501 	orrs.w	r5, r0, r1, lsl #12
     69e:	bf18      	it	ne
     6a0:	ea52 3503 	orrsne.w	r5, r2, r3, lsl #12
     6a4:	f441 1180 	orr.w	r1, r1, #1048576	; 0x100000
     6a8:	f443 1380 	orr.w	r3, r3, #1048576	; 0x100000
     6ac:	d038      	beq.n	720 <__aeabi_dmul+0xb4>
     6ae:	fba0 ce02 	umull	ip, lr, r0, r2
     6b2:	f04f 0500 	mov.w	r5, #0
     6b6:	fbe1 e502 	umlal	lr, r5, r1, r2
     6ba:	f006 4200 	and.w	r2, r6, #2147483648	; 0x80000000
     6be:	fbe0 e503 	umlal	lr, r5, r0, r3
     6c2:	f04f 0600 	mov.w	r6, #0
     6c6:	fbe1 5603 	umlal	r5, r6, r1, r3
     6ca:	f09c 0f00 	teq	ip, #0
     6ce:	bf18      	it	ne
     6d0:	f04e 0e01 	orrne.w	lr, lr, #1
     6d4:	f1a4 04ff 	sub.w	r4, r4, #255	; 0xff
     6d8:	f5b6 7f00 	cmp.w	r6, #512	; 0x200
     6dc:	f564 7440 	sbc.w	r4, r4, #768	; 0x300
     6e0:	d204      	bcs.n	6ec <__aeabi_dmul+0x80>
     6e2:	ea5f 0e4e 	movs.w	lr, lr, lsl #1
     6e6:	416d      	adcs	r5, r5
     6e8:	eb46 0606 	adc.w	r6, r6, r6
     6ec:	ea42 21c6 	orr.w	r1, r2, r6, lsl #11
     6f0:	ea41 5155 	orr.w	r1, r1, r5, lsr #21
     6f4:	ea4f 20c5 	mov.w	r0, r5, lsl #11
     6f8:	ea40 505e 	orr.w	r0, r0, lr, lsr #21
     6fc:	ea4f 2ece 	mov.w	lr, lr, lsl #11
     700:	f1b4 0cfd 	subs.w	ip, r4, #253	; 0xfd
     704:	bf88      	it	hi
     706:	f5bc 6fe0 	cmphi.w	ip, #1792	; 0x700
     70a:	d81e      	bhi.n	74a <__aeabi_dmul+0xde>
     70c:	f1be 4f00 	cmp.w	lr, #2147483648	; 0x80000000
     710:	bf08      	it	eq
     712:	ea5f 0e50 	movseq.w	lr, r0, lsr #1
     716:	f150 0000 	adcs.w	r0, r0, #0
     71a:	eb41 5104 	adc.w	r1, r1, r4, lsl #20
     71e:	bd70      	pop	{r4, r5, r6, pc}
     720:	f006 4600 	and.w	r6, r6, #2147483648	; 0x80000000
     724:	ea46 0101 	orr.w	r1, r6, r1
     728:	ea40 0002 	orr.w	r0, r0, r2
     72c:	ea81 0103 	eor.w	r1, r1, r3
     730:	ebb4 045c 	subs.w	r4, r4, ip, lsr #1
     734:	bfc2      	ittt	gt
     736:	ebd4 050c 	rsbsgt	r5, r4, ip
     73a:	ea41 5104 	orrgt.w	r1, r1, r4, lsl #20
     73e:	bd70      	popgt	{r4, r5, r6, pc}
     740:	f441 1180 	orr.w	r1, r1, #1048576	; 0x100000
     744:	f04f 0e00 	mov.w	lr, #0
     748:	3c01      	subs	r4, #1
     74a:	f300 80ab 	bgt.w	8a4 <__aeabi_dmul+0x238>
     74e:	f114 0f36 	cmn.w	r4, #54	; 0x36
     752:	bfde      	ittt	le
     754:	2000      	movle	r0, #0
     756:	f001 4100 	andle.w	r1, r1, #2147483648	; 0x80000000
     75a:	bd70      	pople	{r4, r5, r6, pc}
     75c:	f1c4 0400 	rsb	r4, r4, #0
     760:	3c20      	subs	r4, #32
     762:	da35      	bge.n	7d0 <__aeabi_dmul+0x164>
     764:	340c      	adds	r4, #12
     766:	dc1b      	bgt.n	7a0 <__aeabi_dmul+0x134>
     768:	f104 0414 	add.w	r4, r4, #20
     76c:	f1c4 0520 	rsb	r5, r4, #32
     770:	fa00 f305 	lsl.w	r3, r0, r5
     774:	fa20 f004 	lsr.w	r0, r0, r4
     778:	fa01 f205 	lsl.w	r2, r1, r5
     77c:	ea40 0002 	orr.w	r0, r0, r2
     780:	f001 4200 	and.w	r2, r1, #2147483648	; 0x80000000
     784:	f021 4100 	bic.w	r1, r1, #2147483648	; 0x80000000
     788:	eb10 70d3 	adds.w	r0, r0, r3, lsr #31
     78c:	fa21 f604 	lsr.w	r6, r1, r4
     790:	eb42 0106 	adc.w	r1, r2, r6
     794:	ea5e 0e43 	orrs.w	lr, lr, r3, lsl #1
     798:	bf08      	it	eq
     79a:	ea20 70d3 	biceq.w	r0, r0, r3, lsr #31
     79e:	bd70      	pop	{r4, r5, r6, pc}
     7a0:	f1c4 040c 	rsb	r4, r4, #12
     7a4:	f1c4 0520 	rsb	r5, r4, #32
     7a8:	fa00 f304 	lsl.w	r3, r0, r4
     7ac:	fa20 f005 	lsr.w	r0, r0, r5
     7b0:	fa01 f204 	lsl.w	r2, r1, r4
     7b4:	ea40 0002 	orr.w	r0, r0, r2
     7b8:	f001 4100 	and.w	r1, r1, #2147483648	; 0x80000000
     7bc:	eb10 70d3 	adds.w	r0, r0, r3, lsr #31
     7c0:	f141 0100 	adc.w	r1, r1, #0
     7c4:	ea5e 0e43 	orrs.w	lr, lr, r3, lsl #1
     7c8:	bf08      	it	eq
     7ca:	ea20 70d3 	biceq.w	r0, r0, r3, lsr #31
     7ce:	bd70      	pop	{r4, r5, r6, pc}
     7d0:	f1c4 0520 	rsb	r5, r4, #32
     7d4:	fa00 f205 	lsl.w	r2, r0, r5
     7d8:	ea4e 0e02 	orr.w	lr, lr, r2
     7dc:	fa20 f304 	lsr.w	r3, r0, r4
     7e0:	fa01 f205 	lsl.w	r2, r1, r5
     7e4:	ea43 0302 	orr.w	r3, r3, r2
     7e8:	fa21 f004 	lsr.w	r0, r1, r4
     7ec:	f001 4100 	and.w	r1, r1, #2147483648	; 0x80000000
     7f0:	fa21 f204 	lsr.w	r2, r1, r4
     7f4:	ea20 0002 	bic.w	r0, r0, r2
     7f8:	eb00 70d3 	add.w	r0, r0, r3, lsr #31
     7fc:	ea5e 0e43 	orrs.w	lr, lr, r3, lsl #1
     800:	bf08      	it	eq
     802:	ea20 70d3 	biceq.w	r0, r0, r3, lsr #31
     806:	bd70      	pop	{r4, r5, r6, pc}
     808:	f094 0f00 	teq	r4, #0
     80c:	d10f      	bne.n	82e <__aeabi_dmul+0x1c2>
     80e:	f001 4600 	and.w	r6, r1, #2147483648	; 0x80000000
     812:	0040      	lsls	r0, r0, #1
     814:	eb41 0101 	adc.w	r1, r1, r1
     818:	f411 1f80 	tst.w	r1, #1048576	; 0x100000
     81c:	bf08      	it	eq
     81e:	3c01      	subeq	r4, #1
     820:	d0f7      	beq.n	812 <__aeabi_dmul+0x1a6>
     822:	ea41 0106 	orr.w	r1, r1, r6
     826:	f095 0f00 	teq	r5, #0
     82a:	bf18      	it	ne
     82c:	4770      	bxne	lr
     82e:	f003 4600 	and.w	r6, r3, #2147483648	; 0x80000000
     832:	0052      	lsls	r2, r2, #1
     834:	eb43 0303 	adc.w	r3, r3, r3
     838:	f413 1f80 	tst.w	r3, #1048576	; 0x100000
     83c:	bf08      	it	eq
     83e:	3d01      	subeq	r5, #1
     840:	d0f7      	beq.n	832 <__aeabi_dmul+0x1c6>
     842:	ea43 0306 	orr.w	r3, r3, r6
     846:	4770      	bx	lr
     848:	ea94 0f0c 	teq	r4, ip
     84c:	ea0c 5513 	and.w	r5, ip, r3, lsr #20
     850:	bf18      	it	ne
     852:	ea95 0f0c 	teqne	r5, ip
     856:	d00c      	beq.n	872 <__aeabi_dmul+0x206>
     858:	ea50 0641 	orrs.w	r6, r0, r1, lsl #1
     85c:	bf18      	it	ne
     85e:	ea52 0643 	orrsne.w	r6, r2, r3, lsl #1
     862:	d1d1      	bne.n	808 <__aeabi_dmul+0x19c>
     864:	ea81 0103 	eor.w	r1, r1, r3
     868:	f001 4100 	and.w	r1, r1, #2147483648	; 0x80000000
     86c:	f04f 0000 	mov.w	r0, #0
     870:	bd70      	pop	{r4, r5, r6, pc}
     872:	ea50 0641 	orrs.w	r6, r0, r1, lsl #1
     876:	bf06      	itte	eq
     878:	4610      	moveq	r0, r2
     87a:	4619      	moveq	r1, r3
     87c:	ea52 0643 	orrsne.w	r6, r2, r3, lsl #1
     880:	d019      	beq.n	8b6 <__aeabi_dmul+0x24a>
     882:	ea94 0f0c 	teq	r4, ip
     886:	d102      	bne.n	88e <__aeabi_dmul+0x222>
     888:	ea50 3601 	orrs.w	r6, r0, r1, lsl #12
     88c:	d113      	bne.n	8b6 <__aeabi_dmul+0x24a>
     88e:	ea95 0f0c 	teq	r5, ip
     892:	d105      	bne.n	8a0 <__aeabi_dmul+0x234>
     894:	ea52 3603 	orrs.w	r6, r2, r3, lsl #12
     898:	bf1c      	itt	ne
     89a:	4610      	movne	r0, r2
     89c:	4619      	movne	r1, r3
     89e:	d10a      	bne.n	8b6 <__aeabi_dmul+0x24a>
     8a0:	ea81 0103 	eor.w	r1, r1, r3
     8a4:	f001 4100 	and.w	r1, r1, #2147483648	; 0x80000000
     8a8:	f041 41fe 	orr.w	r1, r1, #2130706432	; 0x7f000000
     8ac:	f441 0170 	orr.w	r1, r1, #15728640	; 0xf00000
     8b0:	f04f 0000 	mov.w	r0, #0
     8b4:	bd70      	pop	{r4, r5, r6, pc}
     8b6:	f041 41fe 	orr.w	r1, r1, #2130706432	; 0x7f000000
     8ba:	f441 0178 	orr.w	r1, r1, #16252928	; 0xf80000
     8be:	bd70      	pop	{r4, r5, r6, pc}

000008c0 <__aeabi_ddiv>:
     8c0:	b570      	push	{r4, r5, r6, lr}
     8c2:	f04f 0cff 	mov.w	ip, #255	; 0xff
     8c6:	f44c 6ce0 	orr.w	ip, ip, #1792	; 0x700
     8ca:	ea1c 5411 	ands.w	r4, ip, r1, lsr #20
     8ce:	bf1d      	ittte	ne
     8d0:	ea1c 5513 	andsne.w	r5, ip, r3, lsr #20
     8d4:	ea94 0f0c 	teqne	r4, ip
     8d8:	ea95 0f0c 	teqne	r5, ip
     8dc:	f000 f8a7 	bleq	a2e <__aeabi_ddiv+0x16e>
     8e0:	eba4 0405 	sub.w	r4, r4, r5
     8e4:	ea81 0e03 	eor.w	lr, r1, r3
     8e8:	ea52 3503 	orrs.w	r5, r2, r3, lsl #12
     8ec:	ea4f 3101 	mov.w	r1, r1, lsl #12
     8f0:	f000 8088 	beq.w	a04 <__aeabi_ddiv+0x144>
     8f4:	ea4f 3303 	mov.w	r3, r3, lsl #12
     8f8:	f04f 5580 	mov.w	r5, #268435456	; 0x10000000
     8fc:	ea45 1313 	orr.w	r3, r5, r3, lsr #4
     900:	ea43 6312 	orr.w	r3, r3, r2, lsr #24
     904:	ea4f 2202 	mov.w	r2, r2, lsl #8
     908:	ea45 1511 	orr.w	r5, r5, r1, lsr #4
     90c:	ea45 6510 	orr.w	r5, r5, r0, lsr #24
     910:	ea4f 2600 	mov.w	r6, r0, lsl #8
     914:	f00e 4100 	and.w	r1, lr, #2147483648	; 0x80000000
     918:	429d      	cmp	r5, r3
     91a:	bf08      	it	eq
     91c:	4296      	cmpeq	r6, r2
     91e:	f144 04fd 	adc.w	r4, r4, #253	; 0xfd
     922:	f504 7440 	add.w	r4, r4, #768	; 0x300
     926:	d202      	bcs.n	92e <__aeabi_ddiv+0x6e>
     928:	085b      	lsrs	r3, r3, #1
     92a:	ea4f 0232 	mov.w	r2, r2, rrx
     92e:	1ab6      	subs	r6, r6, r2
     930:	eb65 0503 	sbc.w	r5, r5, r3
     934:	085b      	lsrs	r3, r3, #1
     936:	ea4f 0232 	mov.w	r2, r2, rrx
     93a:	f44f 1080 	mov.w	r0, #1048576	; 0x100000
     93e:	f44f 2c00 	mov.w	ip, #524288	; 0x80000
     942:	ebb6 0e02 	subs.w	lr, r6, r2
     946:	eb75 0e03 	sbcs.w	lr, r5, r3
     94a:	bf22      	ittt	cs
     94c:	1ab6      	subcs	r6, r6, r2
     94e:	4675      	movcs	r5, lr
     950:	ea40 000c 	orrcs.w	r0, r0, ip
     954:	085b      	lsrs	r3, r3, #1
     956:	ea4f 0232 	mov.w	r2, r2, rrx
     95a:	ebb6 0e02 	subs.w	lr, r6, r2
     95e:	eb75 0e03 	sbcs.w	lr, r5, r3
     962:	bf22      	ittt	cs
     964:	1ab6      	subcs	r6, r6, r2
     966:	4675      	movcs	r5, lr
     968:	ea40 005c 	orrcs.w	r0, r0, ip, lsr #1
     96c:	085b      	lsrs	r3, r3, #1
     96e:	ea4f 0232 	mov.w	r2, r2, rrx
     972:	ebb6 0e02 	subs.w	lr, r6, r2
     976:	eb75 0e03 	sbcs.w	lr, r5, r3
     97a:	bf22      	ittt	cs
     97c:	1ab6      	subcs	r6, r6, r2
     97e:	4675      	movcs	r5, lr
     980:	ea40 009c 	orrcs.w	r0, r0, ip, lsr #2
     984:	085b      	lsrs	r3, r3, #1
     986:	ea4f 0232 	mov.w	r2, r2, rrx
     98a:	ebb6 0e02 	subs.w	lr, r6, r2
     98e:	eb75 0e03 	sbcs.w	lr, r5, r3
     992:	bf22      	ittt	cs
     994:	1ab6      	subcs	r6, r6, r2
     996:	4675      	movcs	r5, lr
     998:	ea40 00dc 	orrcs.w	r0, r0, ip, lsr #3
     99c:	ea55 0e06 	orrs.w	lr, r5, r6
     9a0:	d018      	beq.n	9d4 <__aeabi_ddiv+0x114>
     9a2:	ea4f 1505 	mov.w	r5, r5, lsl #4
     9a6:	ea45 7516 	orr.w	r5, r5, r6, lsr #28
     9aa:	ea4f 1606 	mov.w	r6, r6, lsl #4
     9ae:	ea4f 03c3 	mov.w	r3, r3, lsl #3
     9b2:	ea43 7352 	orr.w	r3, r3, r2, lsr #29
     9b6:	ea4f 02c2 	mov.w	r2, r2, lsl #3
     9ba:	ea5f 1c1c 	movs.w	ip, ip, lsr #4
     9be:	d1c0      	bne.n	942 <__aeabi_ddiv+0x82>
     9c0:	f411 1f80 	tst.w	r1, #1048576	; 0x100000
     9c4:	d10b      	bne.n	9de <__aeabi_ddiv+0x11e>
     9c6:	ea41 0100 	orr.w	r1, r1, r0
     9ca:	f04f 0000 	mov.w	r0, #0
     9ce:	f04f 4c00 	mov.w	ip, #2147483648	; 0x80000000
     9d2:	e7b6      	b.n	942 <__aeabi_ddiv+0x82>
     9d4:	f411 1f80 	tst.w	r1, #1048576	; 0x100000
     9d8:	bf04      	itt	eq
     9da:	4301      	orreq	r1, r0
     9dc:	2000      	moveq	r0, #0
     9de:	f1b4 0cfd 	subs.w	ip, r4, #253	; 0xfd
     9e2:	bf88      	it	hi
     9e4:	f5bc 6fe0 	cmphi.w	ip, #1792	; 0x700
     9e8:	f63f aeaf 	bhi.w	74a <__aeabi_dmul+0xde>
     9ec:	ebb5 0c03 	subs.w	ip, r5, r3
     9f0:	bf04      	itt	eq
     9f2:	ebb6 0c02 	subseq.w	ip, r6, r2
     9f6:	ea5f 0c50 	movseq.w	ip, r0, lsr #1
     9fa:	f150 0000 	adcs.w	r0, r0, #0
     9fe:	eb41 5104 	adc.w	r1, r1, r4, lsl #20
     a02:	bd70      	pop	{r4, r5, r6, pc}
     a04:	f00e 4e00 	and.w	lr, lr, #2147483648	; 0x80000000
     a08:	ea4e 3111 	orr.w	r1, lr, r1, lsr #12
     a0c:	eb14 045c 	adds.w	r4, r4, ip, lsr #1
     a10:	bfc2      	ittt	gt
     a12:	ebd4 050c 	rsbsgt	r5, r4, ip
     a16:	ea41 5104 	orrgt.w	r1, r1, r4, lsl #20
     a1a:	bd70      	popgt	{r4, r5, r6, pc}
     a1c:	f441 1180 	orr.w	r1, r1, #1048576	; 0x100000
     a20:	f04f 0e00 	mov.w	lr, #0
     a24:	3c01      	subs	r4, #1
     a26:	e690      	b.n	74a <__aeabi_dmul+0xde>
     a28:	ea45 0e06 	orr.w	lr, r5, r6
     a2c:	e68d      	b.n	74a <__aeabi_dmul+0xde>
     a2e:	ea0c 5513 	and.w	r5, ip, r3, lsr #20
     a32:	ea94 0f0c 	teq	r4, ip
     a36:	bf08      	it	eq
     a38:	ea95 0f0c 	teqeq	r5, ip
     a3c:	f43f af3b 	beq.w	8b6 <__aeabi_dmul+0x24a>
     a40:	ea94 0f0c 	teq	r4, ip
     a44:	d10a      	bne.n	a5c <__aeabi_ddiv+0x19c>
     a46:	ea50 3401 	orrs.w	r4, r0, r1, lsl #12
     a4a:	f47f af34 	bne.w	8b6 <__aeabi_dmul+0x24a>
     a4e:	ea95 0f0c 	teq	r5, ip
     a52:	f47f af25 	bne.w	8a0 <__aeabi_dmul+0x234>
     a56:	4610      	mov	r0, r2
     a58:	4619      	mov	r1, r3
     a5a:	e72c      	b.n	8b6 <__aeabi_dmul+0x24a>
     a5c:	ea95 0f0c 	teq	r5, ip
     a60:	d106      	bne.n	a70 <__aeabi_ddiv+0x1b0>
     a62:	ea52 3503 	orrs.w	r5, r2, r3, lsl #12
     a66:	f43f aefd 	beq.w	864 <__aeabi_dmul+0x1f8>
     a6a:	4610      	mov	r0, r2
     a6c:	4619      	mov	r1, r3
     a6e:	e722      	b.n	8b6 <__aeabi_dmul+0x24a>
     a70:	ea50 0641 	orrs.w	r6, r0, r1, lsl #1
     a74:	bf18      	it	ne
     a76:	ea52 0643 	orrsne.w	r6, r2, r3, lsl #1
     a7a:	f47f aec5 	bne.w	808 <__aeabi_dmul+0x19c>
     a7e:	ea50 0441 	orrs.w	r4, r0, r1, lsl #1
     a82:	f47f af0d 	bne.w	8a0 <__aeabi_dmul+0x234>
     a86:	ea52 0543 	orrs.w	r5, r2, r3, lsl #1
     a8a:	f47f aeeb 	bne.w	864 <__aeabi_dmul+0x1f8>
     a8e:	e712      	b.n	8b6 <__aeabi_dmul+0x24a>

00000a90 <__gedf2>:
     a90:	f04f 3cff 	mov.w	ip, #4294967295
     a94:	e006      	b.n	aa4 <__cmpdf2+0x4>
     a96:	bf00      	nop

00000a98 <__ledf2>:
     a98:	f04f 0c01 	mov.w	ip, #1
     a9c:	e002      	b.n	aa4 <__cmpdf2+0x4>
     a9e:	bf00      	nop

00000aa0 <__cmpdf2>:
     aa0:	f04f 0c01 	mov.w	ip, #1
     aa4:	f84d cd04 	str.w	ip, [sp, #-4]!
     aa8:	ea4f 0c41 	mov.w	ip, r1, lsl #1
     aac:	ea7f 5c6c 	mvns.w	ip, ip, asr #21
     ab0:	ea4f 0c43 	mov.w	ip, r3, lsl #1
     ab4:	bf18      	it	ne
     ab6:	ea7f 5c6c 	mvnsne.w	ip, ip, asr #21
     aba:	d01b      	beq.n	af4 <__cmpdf2+0x54>
     abc:	b001      	add	sp, #4
     abe:	ea50 0c41 	orrs.w	ip, r0, r1, lsl #1
     ac2:	bf0c      	ite	eq
     ac4:	ea52 0c43 	orrseq.w	ip, r2, r3, lsl #1
     ac8:	ea91 0f03 	teqne	r1, r3
     acc:	bf02      	ittt	eq
     ace:	ea90 0f02 	teqeq	r0, r2
     ad2:	2000      	moveq	r0, #0
     ad4:	4770      	bxeq	lr
     ad6:	f110 0f00 	cmn.w	r0, #0
     ada:	ea91 0f03 	teq	r1, r3
     ade:	bf58      	it	pl
     ae0:	4299      	cmppl	r1, r3
     ae2:	bf08      	it	eq
     ae4:	4290      	cmpeq	r0, r2
     ae6:	bf2c      	ite	cs
     ae8:	17d8      	asrcs	r0, r3, #31
     aea:	ea6f 70e3 	mvncc.w	r0, r3, asr #31
     aee:	f040 0001 	orr.w	r0, r0, #1
     af2:	4770      	bx	lr
     af4:	ea4f 0c41 	mov.w	ip, r1, lsl #1
     af8:	ea7f 5c6c 	mvns.w	ip, ip, asr #21
     afc:	d102      	bne.n	b04 <__cmpdf2+0x64>
     afe:	ea50 3c01 	orrs.w	ip, r0, r1, lsl #12
     b02:	d107      	bne.n	b14 <__cmpdf2+0x74>
     b04:	ea4f 0c43 	mov.w	ip, r3, lsl #1
     b08:	ea7f 5c6c 	mvns.w	ip, ip, asr #21
     b0c:	d1d6      	bne.n	abc <__cmpdf2+0x1c>
     b0e:	ea52 3c03 	orrs.w	ip, r2, r3, lsl #12
     b12:	d0d3      	beq.n	abc <__cmpdf2+0x1c>
     b14:	f85d 0b04 	ldr.w	r0, [sp], #4
     b18:	4770      	bx	lr
     b1a:	bf00      	nop

00000b1c <__aeabi_cdrcmple>:
     b1c:	4684      	mov	ip, r0
     b1e:	4610      	mov	r0, r2
     b20:	4662      	mov	r2, ip
     b22:	468c      	mov	ip, r1
     b24:	4619      	mov	r1, r3
     b26:	4663      	mov	r3, ip
     b28:	e000      	b.n	b2c <__aeabi_cdcmpeq>
     b2a:	bf00      	nop

00000b2c <__aeabi_cdcmpeq>:
     b2c:	b501      	push	{r0, lr}
     b2e:	f7ff ffb7 	bl	aa0 <__cmpdf2>
     b32:	2800      	cmp	r0, #0
     b34:	bf48      	it	mi
     b36:	f110 0f00 	cmnmi.w	r0, #0
     b3a:	bd01      	pop	{r0, pc}

00000b3c <__aeabi_dcmpeq>:
     b3c:	f84d ed08 	str.w	lr, [sp, #-8]!
     b40:	f7ff fff4 	bl	b2c <__aeabi_cdcmpeq>
     b44:	bf0c      	ite	eq
     b46:	2001      	moveq	r0, #1
     b48:	2000      	movne	r0, #0
     b4a:	f85d fb08 	ldr.w	pc, [sp], #8
     b4e:	bf00      	nop

00000b50 <__aeabi_dcmplt>:
     b50:	f84d ed08 	str.w	lr, [sp, #-8]!
     b54:	f7ff ffea 	bl	b2c <__aeabi_cdcmpeq>
     b58:	bf34      	ite	cc
     b5a:	2001      	movcc	r0, #1
     b5c:	2000      	movcs	r0, #0
     b5e:	f85d fb08 	ldr.w	pc, [sp], #8
     b62:	bf00      	nop

00000b64 <__aeabi_dcmple>:
     b64:	f84d ed08 	str.w	lr, [sp, #-8]!
     b68:	f7ff ffe0 	bl	b2c <__aeabi_cdcmpeq>
     b6c:	bf94      	ite	ls
     b6e:	2001      	movls	r0, #1
     b70:	2000      	movhi	r0, #0
     b72:	f85d fb08 	ldr.w	pc, [sp], #8
     b76:	bf00      	nop

00000b78 <__aeabi_dcmpge>:
     b78:	f84d ed08 	str.w	lr, [sp, #-8]!
     b7c:	f7ff ffce 	bl	b1c <__aeabi_cdrcmple>
     b80:	bf94      	ite	ls
     b82:	2001      	movls	r0, #1
     b84:	2000      	movhi	r0, #0
     b86:	f85d fb08 	ldr.w	pc, [sp], #8
     b8a:	bf00      	nop

00000b8c <__aeabi_dcmpgt>:
     b8c:	f84d ed08 	str.w	lr, [sp, #-8]!
     b90:	f7ff ffc4 	bl	b1c <__aeabi_cdrcmple>
     b94:	bf34      	ite	cc
     b96:	2001      	movcc	r0, #1
     b98:	2000      	movcs	r0, #0
     b9a:	f85d fb08 	ldr.w	pc, [sp], #8
     b9e:	bf00      	nop

00000ba0 <__aeabi_d2iz>:
     ba0:	ea4f 0241 	mov.w	r2, r1, lsl #1
     ba4:	f512 1200 	adds.w	r2, r2, #2097152	; 0x200000
     ba8:	d215      	bcs.n	bd6 <__aeabi_d2iz+0x36>
     baa:	d511      	bpl.n	bd0 <__aeabi_d2iz+0x30>
     bac:	f46f 7378 	mvn.w	r3, #992	; 0x3e0
     bb0:	ebb3 5262 	subs.w	r2, r3, r2, asr #21
     bb4:	d912      	bls.n	bdc <__aeabi_d2iz+0x3c>
     bb6:	ea4f 23c1 	mov.w	r3, r1, lsl #11
     bba:	f043 4300 	orr.w	r3, r3, #2147483648	; 0x80000000
     bbe:	ea43 5350 	orr.w	r3, r3, r0, lsr #21
     bc2:	f011 4f00 	tst.w	r1, #2147483648	; 0x80000000
     bc6:	fa23 f002 	lsr.w	r0, r3, r2
     bca:	bf18      	it	ne
     bcc:	4240      	negne	r0, r0
     bce:	4770      	bx	lr
     bd0:	f04f 0000 	mov.w	r0, #0
     bd4:	4770      	bx	lr
     bd6:	ea50 3001 	orrs.w	r0, r0, r1, lsl #12
     bda:	d105      	bne.n	be8 <__aeabi_d2iz+0x48>
     bdc:	f011 4000 	ands.w	r0, r1, #2147483648	; 0x80000000
     be0:	bf08      	it	eq
     be2:	f06f 4000 	mvneq.w	r0, #2147483648	; 0x80000000
     be6:	4770      	bx	lr
     be8:	f04f 0000 	mov.w	r0, #0
     bec:	4770      	bx	lr
     bee:	bf00      	nop

00000bf0 <__aeabi_frsub>:
     bf0:	f080 4000 	eor.w	r0, r0, #2147483648	; 0x80000000
     bf4:	e002      	b.n	bfc <__addsf3>
     bf6:	bf00      	nop

00000bf8 <__aeabi_fsub>:
     bf8:	f081 4100 	eor.w	r1, r1, #2147483648	; 0x80000000

00000bfc <__addsf3>:
     bfc:	0042      	lsls	r2, r0, #1
     bfe:	bf1f      	itttt	ne
     c00:	ea5f 0341 	movsne.w	r3, r1, lsl #1
     c04:	ea92 0f03 	teqne	r2, r3
     c08:	ea7f 6c22 	mvnsne.w	ip, r2, asr #24
     c0c:	ea7f 6c23 	mvnsne.w	ip, r3, asr #24
     c10:	d06a      	beq.n	ce8 <__addsf3+0xec>
     c12:	ea4f 6212 	mov.w	r2, r2, lsr #24
     c16:	ebd2 6313 	rsbs	r3, r2, r3, lsr #24
     c1a:	bfc1      	itttt	gt
     c1c:	18d2      	addgt	r2, r2, r3
     c1e:	4041      	eorgt	r1, r0
     c20:	4048      	eorgt	r0, r1
     c22:	4041      	eorgt	r1, r0
     c24:	bfb8      	it	lt
     c26:	425b      	neglt	r3, r3
     c28:	2b19      	cmp	r3, #25
     c2a:	bf88      	it	hi
     c2c:	4770      	bxhi	lr
     c2e:	f010 4f00 	tst.w	r0, #2147483648	; 0x80000000
     c32:	f440 0000 	orr.w	r0, r0, #8388608	; 0x800000
     c36:	f020 407f 	bic.w	r0, r0, #4278190080	; 0xff000000
     c3a:	bf18      	it	ne
     c3c:	4240      	negne	r0, r0
     c3e:	f011 4f00 	tst.w	r1, #2147483648	; 0x80000000
     c42:	f441 0100 	orr.w	r1, r1, #8388608	; 0x800000
     c46:	f021 417f 	bic.w	r1, r1, #4278190080	; 0xff000000
     c4a:	bf18      	it	ne
     c4c:	4249      	negne	r1, r1
     c4e:	ea92 0f03 	teq	r2, r3
     c52:	d03f      	beq.n	cd4 <__addsf3+0xd8>
     c54:	f1a2 0201 	sub.w	r2, r2, #1
     c58:	fa41 fc03 	asr.w	ip, r1, r3
     c5c:	eb10 000c 	adds.w	r0, r0, ip
     c60:	f1c3 0320 	rsb	r3, r3, #32
     c64:	fa01 f103 	lsl.w	r1, r1, r3
     c68:	f000 4300 	and.w	r3, r0, #2147483648	; 0x80000000
     c6c:	d502      	bpl.n	c74 <__addsf3+0x78>
     c6e:	4249      	negs	r1, r1
     c70:	eb60 0040 	sbc.w	r0, r0, r0, lsl #1
     c74:	f5b0 0f00 	cmp.w	r0, #8388608	; 0x800000
     c78:	d313      	bcc.n	ca2 <__addsf3+0xa6>
     c7a:	f1b0 7f80 	cmp.w	r0, #16777216	; 0x1000000
     c7e:	d306      	bcc.n	c8e <__addsf3+0x92>
     c80:	0840      	lsrs	r0, r0, #1
     c82:	ea4f 0131 	mov.w	r1, r1, rrx
     c86:	f102 0201 	add.w	r2, r2, #1
     c8a:	2afe      	cmp	r2, #254	; 0xfe
     c8c:	d251      	bcs.n	d32 <__addsf3+0x136>
     c8e:	f1b1 4f00 	cmp.w	r1, #2147483648	; 0x80000000
     c92:	eb40 50c2 	adc.w	r0, r0, r2, lsl #23
     c96:	bf08      	it	eq
     c98:	f020 0001 	biceq.w	r0, r0, #1
     c9c:	ea40 0003 	orr.w	r0, r0, r3
     ca0:	4770      	bx	lr
     ca2:	0049      	lsls	r1, r1, #1
     ca4:	eb40 0000 	adc.w	r0, r0, r0
     ca8:	f410 0f00 	tst.w	r0, #8388608	; 0x800000
     cac:	f1a2 0201 	sub.w	r2, r2, #1
     cb0:	d1ed      	bne.n	c8e <__addsf3+0x92>
     cb2:	fab0 fc80 	clz	ip, r0
     cb6:	f1ac 0c08 	sub.w	ip, ip, #8
     cba:	ebb2 020c 	subs.w	r2, r2, ip
     cbe:	fa00 f00c 	lsl.w	r0, r0, ip
     cc2:	bfaa      	itet	ge
     cc4:	eb00 50c2 	addge.w	r0, r0, r2, lsl #23
     cc8:	4252      	neglt	r2, r2
     cca:	4318      	orrge	r0, r3
     ccc:	bfbc      	itt	lt
     cce:	40d0      	lsrlt	r0, r2
     cd0:	4318      	orrlt	r0, r3
     cd2:	4770      	bx	lr
     cd4:	f092 0f00 	teq	r2, #0
     cd8:	f481 0100 	eor.w	r1, r1, #8388608	; 0x800000
     cdc:	bf06      	itte	eq
     cde:	f480 0000 	eoreq.w	r0, r0, #8388608	; 0x800000
     ce2:	3201      	addeq	r2, #1
     ce4:	3b01      	subne	r3, #1
     ce6:	e7b5      	b.n	c54 <__addsf3+0x58>
     ce8:	ea4f 0341 	mov.w	r3, r1, lsl #1
     cec:	ea7f 6c22 	mvns.w	ip, r2, asr #24
     cf0:	bf18      	it	ne
     cf2:	ea7f 6c23 	mvnsne.w	ip, r3, asr #24
     cf6:	d021      	beq.n	d3c <__addsf3+0x140>
     cf8:	ea92 0f03 	teq	r2, r3
     cfc:	d004      	beq.n	d08 <__addsf3+0x10c>
     cfe:	f092 0f00 	teq	r2, #0
     d02:	bf08      	it	eq
     d04:	4608      	moveq	r0, r1
     d06:	4770      	bx	lr
     d08:	ea90 0f01 	teq	r0, r1
     d0c:	bf1c      	itt	ne
     d0e:	2000      	movne	r0, #0
     d10:	4770      	bxne	lr
     d12:	f012 4f7f 	tst.w	r2, #4278190080	; 0xff000000
     d16:	d104      	bne.n	d22 <__addsf3+0x126>
     d18:	0040      	lsls	r0, r0, #1
     d1a:	bf28      	it	cs
     d1c:	f040 4000 	orrcs.w	r0, r0, #2147483648	; 0x80000000
     d20:	4770      	bx	lr
     d22:	f112 7200 	adds.w	r2, r2, #33554432	; 0x2000000
     d26:	bf3c      	itt	cc
     d28:	f500 0000 	addcc.w	r0, r0, #8388608	; 0x800000
     d2c:	4770      	bxcc	lr
     d2e:	f000 4300 	and.w	r3, r0, #2147483648	; 0x80000000
     d32:	f043 40fe 	orr.w	r0, r3, #2130706432	; 0x7f000000
     d36:	f440 0000 	orr.w	r0, r0, #8388608	; 0x800000
     d3a:	4770      	bx	lr
     d3c:	ea7f 6222 	mvns.w	r2, r2, asr #24
     d40:	bf16      	itet	ne
     d42:	4608      	movne	r0, r1
     d44:	ea7f 6323 	mvnseq.w	r3, r3, asr #24
     d48:	4601      	movne	r1, r0
     d4a:	0242      	lsls	r2, r0, #9
     d4c:	bf06      	itte	eq
     d4e:	ea5f 2341 	movseq.w	r3, r1, lsl #9
     d52:	ea90 0f01 	teqeq	r0, r1
     d56:	f440 0080 	orrne.w	r0, r0, #4194304	; 0x400000
     d5a:	4770      	bx	lr

00000d5c <__aeabi_ui2f>:
     d5c:	f04f 0300 	mov.w	r3, #0
     d60:	e004      	b.n	d6c <__aeabi_i2f+0x8>
     d62:	bf00      	nop

00000d64 <__aeabi_i2f>:
     d64:	f010 4300 	ands.w	r3, r0, #2147483648	; 0x80000000
     d68:	bf48      	it	mi
     d6a:	4240      	negmi	r0, r0
     d6c:	ea5f 0c00 	movs.w	ip, r0
     d70:	bf08      	it	eq
     d72:	4770      	bxeq	lr
     d74:	f043 4396 	orr.w	r3, r3, #1258291200	; 0x4b000000
     d78:	4601      	mov	r1, r0
     d7a:	f04f 0000 	mov.w	r0, #0
     d7e:	e01c      	b.n	dba <__aeabi_l2f+0x2a>

00000d80 <__aeabi_ul2f>:
     d80:	ea50 0201 	orrs.w	r2, r0, r1
     d84:	bf08      	it	eq
     d86:	4770      	bxeq	lr
     d88:	f04f 0300 	mov.w	r3, #0
     d8c:	e00a      	b.n	da4 <__aeabi_l2f+0x14>
     d8e:	bf00      	nop

00000d90 <__aeabi_l2f>:
     d90:	ea50 0201 	orrs.w	r2, r0, r1
     d94:	bf08      	it	eq
     d96:	4770      	bxeq	lr
     d98:	f011 4300 	ands.w	r3, r1, #2147483648	; 0x80000000
     d9c:	d502      	bpl.n	da4 <__aeabi_l2f+0x14>
     d9e:	4240      	negs	r0, r0
     da0:	eb61 0141 	sbc.w	r1, r1, r1, lsl #1
     da4:	ea5f 0c01 	movs.w	ip, r1
     da8:	bf02      	ittt	eq
     daa:	4684      	moveq	ip, r0
     dac:	4601      	moveq	r1, r0
     dae:	2000      	moveq	r0, #0
     db0:	f043 43b6 	orr.w	r3, r3, #1526726656	; 0x5b000000
     db4:	bf08      	it	eq
     db6:	f1a3 5380 	subeq.w	r3, r3, #268435456	; 0x10000000
     dba:	f5a3 0300 	sub.w	r3, r3, #8388608	; 0x800000
     dbe:	fabc f28c 	clz	r2, ip
     dc2:	3a08      	subs	r2, #8
     dc4:	eba3 53c2 	sub.w	r3, r3, r2, lsl #23
     dc8:	db10      	blt.n	dec <__aeabi_l2f+0x5c>
     dca:	fa01 fc02 	lsl.w	ip, r1, r2
     dce:	4463      	add	r3, ip
     dd0:	fa00 fc02 	lsl.w	ip, r0, r2
     dd4:	f1c2 0220 	rsb	r2, r2, #32
     dd8:	f1bc 4f00 	cmp.w	ip, #2147483648	; 0x80000000
     ddc:	fa20 f202 	lsr.w	r2, r0, r2
     de0:	eb43 0002 	adc.w	r0, r3, r2
     de4:	bf08      	it	eq
     de6:	f020 0001 	biceq.w	r0, r0, #1
     dea:	4770      	bx	lr
     dec:	f102 0220 	add.w	r2, r2, #32
     df0:	fa01 fc02 	lsl.w	ip, r1, r2
     df4:	f1c2 0220 	rsb	r2, r2, #32
     df8:	ea50 004c 	orrs.w	r0, r0, ip, lsl #1
     dfc:	fa21 f202 	lsr.w	r2, r1, r2
     e00:	eb43 0002 	adc.w	r0, r3, r2
     e04:	bf08      	it	eq
     e06:	ea20 70dc 	biceq.w	r0, r0, ip, lsr #31
     e0a:	4770      	bx	lr

00000e0c <__aeabi_fmul>:
     e0c:	f04f 0cff 	mov.w	ip, #255	; 0xff
     e10:	ea1c 52d0 	ands.w	r2, ip, r0, lsr #23
     e14:	bf1e      	ittt	ne
     e16:	ea1c 53d1 	andsne.w	r3, ip, r1, lsr #23
     e1a:	ea92 0f0c 	teqne	r2, ip
     e1e:	ea93 0f0c 	teqne	r3, ip
     e22:	d06f      	beq.n	f04 <__aeabi_fmul+0xf8>
     e24:	441a      	add	r2, r3
     e26:	ea80 0c01 	eor.w	ip, r0, r1
     e2a:	0240      	lsls	r0, r0, #9
     e2c:	bf18      	it	ne
     e2e:	ea5f 2141 	movsne.w	r1, r1, lsl #9
     e32:	d01e      	beq.n	e72 <__aeabi_fmul+0x66>
     e34:	f04f 6300 	mov.w	r3, #134217728	; 0x8000000
     e38:	ea43 1050 	orr.w	r0, r3, r0, lsr #5
     e3c:	ea43 1151 	orr.w	r1, r3, r1, lsr #5
     e40:	fba0 3101 	umull	r3, r1, r0, r1
     e44:	f00c 4000 	and.w	r0, ip, #2147483648	; 0x80000000
     e48:	f5b1 0f00 	cmp.w	r1, #8388608	; 0x800000
     e4c:	bf3e      	ittt	cc
     e4e:	0049      	lslcc	r1, r1, #1
     e50:	ea41 71d3 	orrcc.w	r1, r1, r3, lsr #31
     e54:	005b      	lslcc	r3, r3, #1
     e56:	ea40 0001 	orr.w	r0, r0, r1
     e5a:	f162 027f 	sbc.w	r2, r2, #127	; 0x7f
     e5e:	2afd      	cmp	r2, #253	; 0xfd
     e60:	d81d      	bhi.n	e9e <__aeabi_fmul+0x92>
     e62:	f1b3 4f00 	cmp.w	r3, #2147483648	; 0x80000000
     e66:	eb40 50c2 	adc.w	r0, r0, r2, lsl #23
     e6a:	bf08      	it	eq
     e6c:	f020 0001 	biceq.w	r0, r0, #1
     e70:	4770      	bx	lr
     e72:	f090 0f00 	teq	r0, #0
     e76:	f00c 4c00 	and.w	ip, ip, #2147483648	; 0x80000000
     e7a:	bf08      	it	eq
     e7c:	0249      	lsleq	r1, r1, #9
     e7e:	ea4c 2050 	orr.w	r0, ip, r0, lsr #9
     e82:	ea40 2051 	orr.w	r0, r0, r1, lsr #9
     e86:	3a7f      	subs	r2, #127	; 0x7f
     e88:	bfc2      	ittt	gt
     e8a:	f1d2 03ff 	rsbsgt	r3, r2, #255	; 0xff
     e8e:	ea40 50c2 	orrgt.w	r0, r0, r2, lsl #23
     e92:	4770      	bxgt	lr
     e94:	f440 0000 	orr.w	r0, r0, #8388608	; 0x800000
     e98:	f04f 0300 	mov.w	r3, #0
     e9c:	3a01      	subs	r2, #1
     e9e:	dc5d      	bgt.n	f5c <__aeabi_fmul+0x150>
     ea0:	f112 0f19 	cmn.w	r2, #25
     ea4:	bfdc      	itt	le
     ea6:	f000 4000 	andle.w	r0, r0, #2147483648	; 0x80000000
     eaa:	4770      	bxle	lr
     eac:	f1c2 0200 	rsb	r2, r2, #0
     eb0:	0041      	lsls	r1, r0, #1
     eb2:	fa21 f102 	lsr.w	r1, r1, r2
     eb6:	f1c2 0220 	rsb	r2, r2, #32
     eba:	fa00 fc02 	lsl.w	ip, r0, r2
     ebe:	ea5f 0031 	movs.w	r0, r1, rrx
     ec2:	f140 0000 	adc.w	r0, r0, #0
     ec6:	ea53 034c 	orrs.w	r3, r3, ip, lsl #1
     eca:	bf08      	it	eq
     ecc:	ea20 70dc 	biceq.w	r0, r0, ip, lsr #31
     ed0:	4770      	bx	lr
     ed2:	f092 0f00 	teq	r2, #0
     ed6:	f000 4c00 	and.w	ip, r0, #2147483648	; 0x80000000
     eda:	bf02      	ittt	eq
     edc:	0040      	lsleq	r0, r0, #1
     ede:	f410 0f00 	tsteq.w	r0, #8388608	; 0x800000
     ee2:	3a01      	subeq	r2, #1
     ee4:	d0f9      	beq.n	eda <__aeabi_fmul+0xce>
     ee6:	ea40 000c 	orr.w	r0, r0, ip
     eea:	f093 0f00 	teq	r3, #0
     eee:	f001 4c00 	and.w	ip, r1, #2147483648	; 0x80000000
     ef2:	bf02      	ittt	eq
     ef4:	0049      	lsleq	r1, r1, #1
     ef6:	f411 0f00 	tsteq.w	r1, #8388608	; 0x800000
     efa:	3b01      	subeq	r3, #1
     efc:	d0f9      	beq.n	ef2 <__aeabi_fmul+0xe6>
     efe:	ea41 010c 	orr.w	r1, r1, ip
     f02:	e78f      	b.n	e24 <__aeabi_fmul+0x18>
     f04:	ea0c 53d1 	and.w	r3, ip, r1, lsr #23
     f08:	ea92 0f0c 	teq	r2, ip
     f0c:	bf18      	it	ne
     f0e:	ea93 0f0c 	teqne	r3, ip
     f12:	d00a      	beq.n	f2a <__aeabi_fmul+0x11e>
     f14:	f030 4c00 	bics.w	ip, r0, #2147483648	; 0x80000000
     f18:	bf18      	it	ne
     f1a:	f031 4c00 	bicsne.w	ip, r1, #2147483648	; 0x80000000
     f1e:	d1d8      	bne.n	ed2 <__aeabi_fmul+0xc6>
     f20:	ea80 0001 	eor.w	r0, r0, r1
     f24:	f000 4000 	and.w	r0, r0, #2147483648	; 0x80000000
     f28:	4770      	bx	lr
     f2a:	f090 0f00 	teq	r0, #0
     f2e:	bf17      	itett	ne
     f30:	f090 4f00 	teqne	r0, #2147483648	; 0x80000000
     f34:	4608      	moveq	r0, r1
     f36:	f091 0f00 	teqne	r1, #0
     f3a:	f091 4f00 	teqne	r1, #2147483648	; 0x80000000
     f3e:	d014      	beq.n	f6a <__aeabi_fmul+0x15e>
     f40:	ea92 0f0c 	teq	r2, ip
     f44:	d101      	bne.n	f4a <__aeabi_fmul+0x13e>
     f46:	0242      	lsls	r2, r0, #9
     f48:	d10f      	bne.n	f6a <__aeabi_fmul+0x15e>
     f4a:	ea93 0f0c 	teq	r3, ip
     f4e:	d103      	bne.n	f58 <__aeabi_fmul+0x14c>
     f50:	024b      	lsls	r3, r1, #9
     f52:	bf18      	it	ne
     f54:	4608      	movne	r0, r1
     f56:	d108      	bne.n	f6a <__aeabi_fmul+0x15e>
     f58:	ea80 0001 	eor.w	r0, r0, r1
     f5c:	f000 4000 	and.w	r0, r0, #2147483648	; 0x80000000
     f60:	f040 40fe 	orr.w	r0, r0, #2130706432	; 0x7f000000
     f64:	f440 0000 	orr.w	r0, r0, #8388608	; 0x800000
     f68:	4770      	bx	lr
     f6a:	f040 40fe 	orr.w	r0, r0, #2130706432	; 0x7f000000
     f6e:	f440 0040 	orr.w	r0, r0, #12582912	; 0xc00000
     f72:	4770      	bx	lr

00000f74 <__aeabi_fdiv>:
     f74:	f04f 0cff 	mov.w	ip, #255	; 0xff
     f78:	ea1c 52d0 	ands.w	r2, ip, r0, lsr #23
     f7c:	bf1e      	ittt	ne
     f7e:	ea1c 53d1 	andsne.w	r3, ip, r1, lsr #23
     f82:	ea92 0f0c 	teqne	r2, ip
     f86:	ea93 0f0c 	teqne	r3, ip
     f8a:	d069      	beq.n	1060 <__aeabi_fdiv+0xec>
     f8c:	eba2 0203 	sub.w	r2, r2, r3
     f90:	ea80 0c01 	eor.w	ip, r0, r1
     f94:	0249      	lsls	r1, r1, #9
     f96:	ea4f 2040 	mov.w	r0, r0, lsl #9
     f9a:	d037      	beq.n	100c <__aeabi_fdiv+0x98>
     f9c:	f04f 5380 	mov.w	r3, #268435456	; 0x10000000
     fa0:	ea43 1111 	orr.w	r1, r3, r1, lsr #4
     fa4:	ea43 1310 	orr.w	r3, r3, r0, lsr #4
     fa8:	f00c 4000 	and.w	r0, ip, #2147483648	; 0x80000000
     fac:	428b      	cmp	r3, r1
     fae:	bf38      	it	cc
     fb0:	005b      	lslcc	r3, r3, #1
     fb2:	f142 027d 	adc.w	r2, r2, #125	; 0x7d
     fb6:	f44f 0c00 	mov.w	ip, #8388608	; 0x800000
     fba:	428b      	cmp	r3, r1
     fbc:	bf24      	itt	cs
     fbe:	1a5b      	subcs	r3, r3, r1
     fc0:	ea40 000c 	orrcs.w	r0, r0, ip
     fc4:	ebb3 0f51 	cmp.w	r3, r1, lsr #1
     fc8:	bf24      	itt	cs
     fca:	eba3 0351 	subcs.w	r3, r3, r1, lsr #1
     fce:	ea40 005c 	orrcs.w	r0, r0, ip, lsr #1
     fd2:	ebb3 0f91 	cmp.w	r3, r1, lsr #2
     fd6:	bf24      	itt	cs
     fd8:	eba3 0391 	subcs.w	r3, r3, r1, lsr #2
     fdc:	ea40 009c 	orrcs.w	r0, r0, ip, lsr #2
     fe0:	ebb3 0fd1 	cmp.w	r3, r1, lsr #3
     fe4:	bf24      	itt	cs
     fe6:	eba3 03d1 	subcs.w	r3, r3, r1, lsr #3
     fea:	ea40 00dc 	orrcs.w	r0, r0, ip, lsr #3
     fee:	011b      	lsls	r3, r3, #4
     ff0:	bf18      	it	ne
     ff2:	ea5f 1c1c 	movsne.w	ip, ip, lsr #4
     ff6:	d1e0      	bne.n	fba <__aeabi_fdiv+0x46>
     ff8:	2afd      	cmp	r2, #253	; 0xfd
     ffa:	f63f af50 	bhi.w	e9e <__aeabi_fmul+0x92>
     ffe:	428b      	cmp	r3, r1
    1000:	eb40 50c2 	adc.w	r0, r0, r2, lsl #23
    1004:	bf08      	it	eq
    1006:	f020 0001 	biceq.w	r0, r0, #1
    100a:	4770      	bx	lr
    100c:	f00c 4c00 	and.w	ip, ip, #2147483648	; 0x80000000
    1010:	ea4c 2050 	orr.w	r0, ip, r0, lsr #9
    1014:	327f      	adds	r2, #127	; 0x7f
    1016:	bfc2      	ittt	gt
    1018:	f1d2 03ff 	rsbsgt	r3, r2, #255	; 0xff
    101c:	ea40 50c2 	orrgt.w	r0, r0, r2, lsl #23
    1020:	4770      	bxgt	lr
    1022:	f440 0000 	orr.w	r0, r0, #8388608	; 0x800000
    1026:	f04f 0300 	mov.w	r3, #0
    102a:	3a01      	subs	r2, #1
    102c:	e737      	b.n	e9e <__aeabi_fmul+0x92>
    102e:	f092 0f00 	teq	r2, #0
    1032:	f000 4c00 	and.w	ip, r0, #2147483648	; 0x80000000
    1036:	bf02      	ittt	eq
    1038:	0040      	lsleq	r0, r0, #1
    103a:	f410 0f00 	tsteq.w	r0, #8388608	; 0x800000
    103e:	3a01      	subeq	r2, #1
    1040:	d0f9      	beq.n	1036 <__aeabi_fdiv+0xc2>
    1042:	ea40 000c 	orr.w	r0, r0, ip
    1046:	f093 0f00 	teq	r3, #0
    104a:	f001 4c00 	and.w	ip, r1, #2147483648	; 0x80000000
    104e:	bf02      	ittt	eq
    1050:	0049      	lsleq	r1, r1, #1
    1052:	f411 0f00 	tsteq.w	r1, #8388608	; 0x800000
    1056:	3b01      	subeq	r3, #1
    1058:	d0f9      	beq.n	104e <__aeabi_fdiv+0xda>
    105a:	ea41 010c 	orr.w	r1, r1, ip
    105e:	e795      	b.n	f8c <__aeabi_fdiv+0x18>
    1060:	ea0c 53d1 	and.w	r3, ip, r1, lsr #23
    1064:	ea92 0f0c 	teq	r2, ip
    1068:	d108      	bne.n	107c <__aeabi_fdiv+0x108>
    106a:	0242      	lsls	r2, r0, #9
    106c:	f47f af7d 	bne.w	f6a <__aeabi_fmul+0x15e>
    1070:	ea93 0f0c 	teq	r3, ip
    1074:	f47f af70 	bne.w	f58 <__aeabi_fmul+0x14c>
    1078:	4608      	mov	r0, r1
    107a:	e776      	b.n	f6a <__aeabi_fmul+0x15e>
    107c:	ea93 0f0c 	teq	r3, ip
    1080:	d104      	bne.n	108c <__aeabi_fdiv+0x118>
    1082:	024b      	lsls	r3, r1, #9
    1084:	f43f af4c 	beq.w	f20 <__aeabi_fmul+0x114>
    1088:	4608      	mov	r0, r1
    108a:	e76e      	b.n	f6a <__aeabi_fmul+0x15e>
    108c:	f030 4c00 	bics.w	ip, r0, #2147483648	; 0x80000000
    1090:	bf18      	it	ne
    1092:	f031 4c00 	bicsne.w	ip, r1, #2147483648	; 0x80000000
    1096:	d1ca      	bne.n	102e <__aeabi_fdiv+0xba>
    1098:	f030 4200 	bics.w	r2, r0, #2147483648	; 0x80000000
    109c:	f47f af5c 	bne.w	f58 <__aeabi_fmul+0x14c>
    10a0:	f031 4300 	bics.w	r3, r1, #2147483648	; 0x80000000
    10a4:	f47f af3c 	bne.w	f20 <__aeabi_fmul+0x114>
    10a8:	e75f      	b.n	f6a <__aeabi_fmul+0x15e>
    10aa:	bf00      	nop

000010ac <strcmp>:
    10ac:	ea80 0c01 	eor.w	ip, r0, r1
    10b0:	f01c 0f03 	tst.w	ip, #3
    10b4:	d137      	bne.n	1126 <strcmp+0x7a>
    10b6:	f010 0c03 	ands.w	ip, r0, #3
    10ba:	f020 0003 	bic.w	r0, r0, #3
    10be:	f021 0103 	bic.w	r1, r1, #3
    10c2:	f850 2b04 	ldr.w	r2, [r0], #4
    10c6:	bf08      	it	eq
    10c8:	f851 3b04 	ldreq.w	r3, [r1], #4
    10cc:	d00e      	beq.n	10ec <strcmp+0x40>
    10ce:	f08c 0c03 	eor.w	ip, ip, #3
    10d2:	f06f 437f 	mvn.w	r3, #4278190080	; 0xff000000
    10d6:	ea4f 0ccc 	mov.w	ip, ip, lsl #3
    10da:	fa23 fc0c 	lsr.w	ip, r3, ip
    10de:	f851 3b04 	ldr.w	r3, [r1], #4
    10e2:	ea42 020c 	orr.w	r2, r2, ip
    10e6:	ea43 030c 	orr.w	r3, r3, ip
    10ea:	bf00      	nop
    10ec:	f1a2 3c01 	sub.w	ip, r2, #16843009	; 0x1010101
    10f0:	429a      	cmp	r2, r3
    10f2:	bf01      	itttt	eq
    10f4:	ea2c 0c02 	biceq.w	ip, ip, r2
    10f8:	f01c 3f80 	tsteq.w	ip, #2155905152	; 0x80808080
    10fc:	f850 2b04 	ldreq.w	r2, [r0], #4
    1100:	f851 3b04 	ldreq.w	r3, [r1], #4
    1104:	d0f2      	beq.n	10ec <strcmp+0x40>
    1106:	ea4f 6002 	mov.w	r0, r2, lsl #24
    110a:	ea4f 2212 	mov.w	r2, r2, lsr #8
    110e:	2801      	cmp	r0, #1
    1110:	bf28      	it	cs
    1112:	ebb0 6f03 	cmpcs.w	r0, r3, lsl #24
    1116:	bf08      	it	eq
    1118:	0a1b      	lsreq	r3, r3, #8
    111a:	d0f4      	beq.n	1106 <strcmp+0x5a>
    111c:	f003 03ff 	and.w	r3, r3, #255	; 0xff
    1120:	0e00      	lsrs	r0, r0, #24
    1122:	1ac0      	subs	r0, r0, r3
    1124:	4770      	bx	lr
    1126:	f010 0f03 	tst.w	r0, #3
    112a:	d00a      	beq.n	1142 <strcmp+0x96>
    112c:	f810 2b01 	ldrb.w	r2, [r0], #1
    1130:	f811 3b01 	ldrb.w	r3, [r1], #1
    1134:	2a01      	cmp	r2, #1
    1136:	bf28      	it	cs
    1138:	429a      	cmpcs	r2, r3
    113a:	d0f4      	beq.n	1126 <strcmp+0x7a>
    113c:	eba2 0003 	sub.w	r0, r2, r3
    1140:	4770      	bx	lr
    1142:	f84d 5d04 	str.w	r5, [sp, #-4]!
    1146:	f850 2b04 	ldr.w	r2, [r0], #4
    114a:	f001 0503 	and.w	r5, r1, #3
    114e:	f021 0103 	bic.w	r1, r1, #3
    1152:	f851 3b04 	ldr.w	r3, [r1], #4
    1156:	2d02      	cmp	r5, #2
    1158:	d026      	beq.n	11a8 <strcmp+0xfc>
    115a:	d84d      	bhi.n	11f8 <strcmp+0x14c>
    115c:	f022 457f 	bic.w	r5, r2, #4278190080	; 0xff000000
    1160:	ebb5 2f13 	cmp.w	r5, r3, lsr #8
    1164:	f1a2 3c01 	sub.w	ip, r2, #16843009	; 0x1010101
    1168:	ea2c 0c02 	bic.w	ip, ip, r2
    116c:	d10d      	bne.n	118a <strcmp+0xde>
    116e:	f01c 3c80 	ands.w	ip, ip, #2155905152	; 0x80808080
    1172:	bf08      	it	eq
    1174:	f851 3b04 	ldreq.w	r3, [r1], #4
    1178:	d10a      	bne.n	1190 <strcmp+0xe4>
    117a:	ea85 0502 	eor.w	r5, r5, r2
    117e:	ebb5 6f03 	cmp.w	r5, r3, lsl #24
    1182:	d10c      	bne.n	119e <strcmp+0xf2>
    1184:	f850 2b04 	ldr.w	r2, [r0], #4
    1188:	e7e8      	b.n	115c <strcmp+0xb0>
    118a:	ea4f 2313 	mov.w	r3, r3, lsr #8
    118e:	e05b      	b.n	1248 <strcmp+0x19c>
    1190:	f03c 4c7f 	bics.w	ip, ip, #4278190080	; 0xff000000
    1194:	d154      	bne.n	1240 <strcmp+0x194>
    1196:	780b      	ldrb	r3, [r1, #0]
    1198:	ea4f 6512 	mov.w	r5, r2, lsr #24
    119c:	e054      	b.n	1248 <strcmp+0x19c>
    119e:	ea4f 6512 	mov.w	r5, r2, lsr #24
    11a2:	f003 03ff 	and.w	r3, r3, #255	; 0xff
    11a6:	e04f      	b.n	1248 <strcmp+0x19c>
    11a8:	ea4f 4502 	mov.w	r5, r2, lsl #16
    11ac:	f1a2 3c01 	sub.w	ip, r2, #16843009	; 0x1010101
    11b0:	ea4f 4515 	mov.w	r5, r5, lsr #16
    11b4:	ea2c 0c02 	bic.w	ip, ip, r2
    11b8:	ebb5 4f13 	cmp.w	r5, r3, lsr #16
    11bc:	d118      	bne.n	11f0 <strcmp+0x144>
    11be:	f01c 3c80 	ands.w	ip, ip, #2155905152	; 0x80808080
    11c2:	bf08      	it	eq
    11c4:	f851 3b04 	ldreq.w	r3, [r1], #4
    11c8:	d107      	bne.n	11da <strcmp+0x12e>
    11ca:	ea85 0502 	eor.w	r5, r5, r2
    11ce:	ebb5 4f03 	cmp.w	r5, r3, lsl #16
    11d2:	d109      	bne.n	11e8 <strcmp+0x13c>
    11d4:	f850 2b04 	ldr.w	r2, [r0], #4
    11d8:	e7e6      	b.n	11a8 <strcmp+0xfc>
    11da:	ea5f 4c0c 	movs.w	ip, ip, lsl #16
    11de:	d12f      	bne.n	1240 <strcmp+0x194>
    11e0:	880b      	ldrh	r3, [r1, #0]
    11e2:	ea4f 4512 	mov.w	r5, r2, lsr #16
    11e6:	e02f      	b.n	1248 <strcmp+0x19c>
    11e8:	ea4f 4303 	mov.w	r3, r3, lsl #16
    11ec:	ea4f 4512 	mov.w	r5, r2, lsr #16
    11f0:	ea4f 4313 	mov.w	r3, r3, lsr #16
    11f4:	e028      	b.n	1248 <strcmp+0x19c>
    11f6:	bf00      	nop
    11f8:	f002 05ff 	and.w	r5, r2, #255	; 0xff
    11fc:	ebb5 6f13 	cmp.w	r5, r3, lsr #24
    1200:	f1a2 3c01 	sub.w	ip, r2, #16843009	; 0x1010101
    1204:	ea2c 0c02 	bic.w	ip, ip, r2
    1208:	d10d      	bne.n	1226 <strcmp+0x17a>
    120a:	f01c 3c80 	ands.w	ip, ip, #2155905152	; 0x80808080
    120e:	bf08      	it	eq
    1210:	f851 3b04 	ldreq.w	r3, [r1], #4
    1214:	d10a      	bne.n	122c <strcmp+0x180>
    1216:	ea85 0502 	eor.w	r5, r5, r2
    121a:	ebb5 2f03 	cmp.w	r5, r3, lsl #8
    121e:	d10a      	bne.n	1236 <strcmp+0x18a>
    1220:	f850 2b04 	ldr.w	r2, [r0], #4
    1224:	e7e8      	b.n	11f8 <strcmp+0x14c>
    1226:	ea4f 6313 	mov.w	r3, r3, lsr #24
    122a:	e00d      	b.n	1248 <strcmp+0x19c>
    122c:	f012 0fff 	tst.w	r2, #255	; 0xff
    1230:	d006      	beq.n	1240 <strcmp+0x194>
    1232:	f851 3b04 	ldr.w	r3, [r1], #4
    1236:	ea4f 2512 	mov.w	r5, r2, lsr #8
    123a:	f023 437f 	bic.w	r3, r3, #4278190080	; 0xff000000
    123e:	e003      	b.n	1248 <strcmp+0x19c>
    1240:	f04f 0000 	mov.w	r0, #0
    1244:	bc20      	pop	{r5}
    1246:	4770      	bx	lr
    1248:	f005 02ff 	and.w	r2, r5, #255	; 0xff
    124c:	f003 00ff 	and.w	r0, r3, #255	; 0xff
    1250:	2801      	cmp	r0, #1
    1252:	bf28      	it	cs
    1254:	4290      	cmpcs	r0, r2
    1256:	bf04      	itt	eq
    1258:	0a2d      	lsreq	r5, r5, #8
    125a:	0a1b      	lsreq	r3, r3, #8
    125c:	d0f4      	beq.n	1248 <strcmp+0x19c>
    125e:	eba2 0000 	sub.w	r0, r2, r0
    1262:	bc20      	pop	{r5}
    1264:	4770      	bx	lr
    1266:	bf00      	nop

Disassembly of section .text.arm_Init:

00001268 <arm_Init>:
		// --------------------------------------------------
		#if defined (arm7tdmi)
		MEMMAP = MEMMAP_FLASH;
		#endif
		#if defined (cortexm3)
		vtor_SetInCode(0); // Definir a tabela de ints no endereço 0 da flash
    1268:	4b3e      	ldr	r3, [pc, #248]	; (1364 <arm_Init+0xfc>)
    126a:	2000      	movs	r0, #0

// -----------------------------------------------------------------------------------------------
// Descrição:	Incialiaza clock do processador e dos barramentos através do STARTUP
// ajustes no makefile 	
// -----------------------------------------------------------------------------------------------
void arm_Init (void) {
    126c:	b570      	push	{r4, r5, r6, lr}
		// --------------------------------------------------
		#if defined (arm7tdmi)
		MEMMAP = MEMMAP_FLASH;
		#endif
		#if defined (cortexm3)
		vtor_SetInCode(0); // Definir a tabela de ints no endereço 0 da flash
    126e:	6018      	str	r0, [r3, #0]
	//		Pois, isto economiza energia
	#if defined (arm7tdmi)
	PCONP = 0;
	#endif
	#if defined (cortexm3)
	PCONP = PCGPIO; // Vamos deixar somente o GPIO habilitado, pois este habilita também os IOCONS (pinsel)
    1270:	4b3d      	ldr	r3, [pc, #244]	; (1368 <arm_Init+0x100>)
    1272:	f44f 4200 	mov.w	r2, #32768	; 0x8000
	cclksel_sysClk();  // Seleciona o oscilador RC para o divisor do CCLK, PCLK e MEMCLK
	cclksel_clkDiv(1); // Divisor 1:1 para o CCLK
	#endif

	#if defined(LPC1751) || defined(LPC1752)
	cclksel_clkDiv(2); 						// Divisor 1:1 para o CCLK
    1276:	493d      	ldr	r1, [pc, #244]	; (136c <arm_Init+0x104>)
	//		Pois, isto economiza energia
	#if defined (arm7tdmi)
	PCONP = 0;
	#endif
	#if defined (cortexm3)
	PCONP = PCGPIO; // Vamos deixar somente o GPIO habilitado, pois este habilita também os IOCONS (pinsel)
    1278:	601a      	str	r2, [r3, #0]
	cclksel_sysClk();  // Seleciona o oscilador RC para o divisor do CCLK, PCLK e MEMCLK
	cclksel_clkDiv(1); // Divisor 1:1 para o CCLK
	#endif

	#if defined(LPC1751) || defined(LPC1752)
	cclksel_clkDiv(2); 						// Divisor 1:1 para o CCLK
    127a:	680b      	ldr	r3, [r1, #0]
	#endif

	#if defined(OSC_XTAL)
	clksrcsel_oscRC(); 						// habilitar o oscilador RC interno para o sistema
    127c:	4a3c      	ldr	r2, [pc, #240]	; (1370 <arm_Init+0x108>)
	cclksel_sysClk();  // Seleciona o oscilador RC para o divisor do CCLK, PCLK e MEMCLK
	cclksel_clkDiv(1); // Divisor 1:1 para o CCLK
	#endif

	#if defined(LPC1751) || defined(LPC1752)
	cclksel_clkDiv(2); 						// Divisor 1:1 para o CCLK
    127e:	f023 03ff 	bic.w	r3, r3, #255	; 0xff
    1282:	f043 0301 	orr.w	r3, r3, #1
    1286:	600b      	str	r3, [r1, #0]
	#endif

	#if defined(OSC_XTAL)
	clksrcsel_oscRC(); 						// habilitar o oscilador RC interno para o sistema
	scs_oscOFF(); 							// Desabiltar o osc MAIN
    1288:	4b3a      	ldr	r3, [pc, #232]	; (1374 <arm_Init+0x10c>)
	#if defined(LPC1751) || defined(LPC1752)
	cclksel_clkDiv(2); 						// Divisor 1:1 para o CCLK
	#endif

	#if defined(OSC_XTAL)
	clksrcsel_oscRC(); 						// habilitar o oscilador RC interno para o sistema
    128a:	6010      	str	r0, [r2, #0]
	scs_oscOFF(); 							// Desabiltar o osc MAIN
    128c:	6818      	ldr	r0, [r3, #0]
    128e:	f020 0020 	bic.w	r0, r0, #32
    1292:	6018      	str	r0, [r3, #0]
	#if (F_CPU > 20000000)
	SCS |= SCS_OSCRANGE_15MHZ_25MHZ;
	#endif
  	scs_oscON();							// Liga o oscilador MAIN
    1294:	6818      	ldr	r0, [r3, #0]
    1296:	f040 0020 	orr.w	r0, r0, #32
    129a:	6018      	str	r0, [r3, #0]
  	while( !(SCS & SCS_OSCSTAT) );			// Espero até que o oscilador principal esteja pronto para uso como fonte de clock para o PLL
    129c:	6818      	ldr	r0, [r3, #0]
    129e:	0640      	lsls	r0, r0, #25
    12a0:	d5fc      	bpl.n	129c <arm_Init+0x34>
  	clksrcsel_oscMAIN(); 					// Habilita o oscilador MAIN para o sistema
    12a2:	2301      	movs	r3, #1
    12a4:	6013      	str	r3, [r2, #0]
  	#endif

  	pll_OFF(); 								// Desabilita PLL
    12a6:	4a34      	ldr	r2, [pc, #208]	; (1378 <arm_Init+0x110>)
    12a8:	2300      	movs	r3, #0
    12aa:	6013      	str	r3, [r2, #0]
  	PLLFEED = 0xAA;	PLLFEED = 0x55;			// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG
  	PLLCFG = PLLCFG_MSEL | PLLCFG_PSEL;		// Ajustando o multiplicador e divisor do PLL
    12ac:	4d33      	ldr	r5, [pc, #204]	; (137c <arm_Init+0x114>)
  	while( !(SCS & SCS_OSCSTAT) );			// Espero até que o oscilador principal esteja pronto para uso como fonte de clock para o PLL
  	clksrcsel_oscMAIN(); 					// Habilita o oscilador MAIN para o sistema
  	#endif

  	pll_OFF(); 								// Desabilita PLL
  	PLLFEED = 0xAA;	PLLFEED = 0x55;			// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG
    12ae:	4b34      	ldr	r3, [pc, #208]	; (1380 <arm_Init+0x118>)
    12b0:	24aa      	movs	r4, #170	; 0xaa
    12b2:	2055      	movs	r0, #85	; 0x55
  	PLLCFG = PLLCFG_MSEL | PLLCFG_PSEL;		// Ajustando o multiplicador e divisor do PLL
    12b4:	260e      	movs	r6, #14
  	while( !(SCS & SCS_OSCSTAT) );			// Espero até que o oscilador principal esteja pronto para uso como fonte de clock para o PLL
  	clksrcsel_oscMAIN(); 					// Habilita o oscilador MAIN para o sistema
  	#endif

  	pll_OFF(); 								// Desabilita PLL
  	PLLFEED = 0xAA;	PLLFEED = 0x55;			// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG
    12b6:	601c      	str	r4, [r3, #0]
    12b8:	6018      	str	r0, [r3, #0]
  	PLLCFG = PLLCFG_MSEL | PLLCFG_PSEL;		// Ajustando o multiplicador e divisor do PLL
    12ba:	602e      	str	r6, [r5, #0]
  	PLLFEED = 0xAA;	PLLFEED = 0x55;			// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG
    12bc:	601c      	str	r4, [r3, #0]
    12be:	6018      	str	r0, [r3, #0]
  	pll_ON();								// Habilita PLL
    12c0:	6815      	ldr	r5, [r2, #0]
    12c2:	f045 0501 	orr.w	r5, r5, #1
    12c6:	6015      	str	r5, [r2, #0]
  	PLLFEED = 0xAA;	PLLFEED = 0x55;			// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG

  	while (!(PLLSTAT & PLLSTAT_LOCK));		// Espera que o PLL trave. No Skyeye não se usa
    12c8:	4d2e      	ldr	r5, [pc, #184]	; (1384 <arm_Init+0x11c>)
  	pll_OFF(); 								// Desabilita PLL
  	PLLFEED = 0xAA;	PLLFEED = 0x55;			// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG
  	PLLCFG = PLLCFG_MSEL | PLLCFG_PSEL;		// Ajustando o multiplicador e divisor do PLL
  	PLLFEED = 0xAA;	PLLFEED = 0x55;			// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG
  	pll_ON();								// Habilita PLL
  	PLLFEED = 0xAA;	PLLFEED = 0x55;			// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG
    12ca:	601c      	str	r4, [r3, #0]
    12cc:	6018      	str	r0, [r3, #0]

  	while (!(PLLSTAT & PLLSTAT_LOCK));		// Espera que o PLL trave. No Skyeye não se usa
    12ce:	6828      	ldr	r0, [r5, #0]
    12d0:	4c2c      	ldr	r4, [pc, #176]	; (1384 <arm_Init+0x11c>)
    12d2:	f010 6f80 	tst.w	r0, #67108864	; 0x4000000
    12d6:	d0fa      	beq.n	12ce <arm_Init+0x66>
  	#if defined(LPC1751) || defined(LPC1752)
  	pll_Connect();							// Conecta PLL
    12d8:	6810      	ldr	r0, [r2, #0]
    12da:	f040 0002 	orr.w	r0, r0, #2
    12de:	6010      	str	r0, [r2, #0]
  	PLLFEED = 0xAA;	PLLFEED = 0x55;			// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG
    12e0:	22aa      	movs	r2, #170	; 0xaa
    12e2:	601a      	str	r2, [r3, #0]
    12e4:	2255      	movs	r2, #85	; 0x55
    12e6:	601a      	str	r2, [r3, #0]
  	while (!(PLLSTAT & PLLSTAT_PLLC));		// Espera que o PLL se conecte ao sistema
    12e8:	6823      	ldr	r3, [r4, #0]
    12ea:	019a      	lsls	r2, r3, #6
    12ec:	d5fc      	bpl.n	12e8 <arm_Init+0x80>
  	#endif

  	#if defined(OSC_XTAL)
  	pll1_OFF(); 							// Desabilita PLL
    12ee:	4a26      	ldr	r2, [pc, #152]	; (1388 <arm_Init+0x120>)
    12f0:	2300      	movs	r3, #0
    12f2:	6013      	str	r3, [r2, #0]
  	PLL1FEED = 0xAA;	PLL1FEED = 0x55;	// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG
  	PLL1CFG = PLL1CFG_MSEL | PLL1CFG_PSEL;	// Ajustando o multiplicador e divisor do PLL
    12f4:	4d25      	ldr	r5, [pc, #148]	; (138c <arm_Init+0x124>)
  	while (!(PLLSTAT & PLLSTAT_PLLC));		// Espera que o PLL se conecte ao sistema
  	#endif

  	#if defined(OSC_XTAL)
  	pll1_OFF(); 							// Desabilita PLL
  	PLL1FEED = 0xAA;	PLL1FEED = 0x55;	// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG
    12f6:	4b26      	ldr	r3, [pc, #152]	; (1390 <arm_Init+0x128>)
    12f8:	24aa      	movs	r4, #170	; 0xaa
    12fa:	2055      	movs	r0, #85	; 0x55
  	PLL1CFG = PLL1CFG_MSEL | PLL1CFG_PSEL;	// Ajustando o multiplicador e divisor do PLL
    12fc:	2607      	movs	r6, #7
  	while (!(PLLSTAT & PLLSTAT_PLLC));		// Espera que o PLL se conecte ao sistema
  	#endif

  	#if defined(OSC_XTAL)
  	pll1_OFF(); 							// Desabilita PLL
  	PLL1FEED = 0xAA;	PLL1FEED = 0x55;	// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG
    12fe:	601c      	str	r4, [r3, #0]
    1300:	6018      	str	r0, [r3, #0]
  	PLL1CFG = PLL1CFG_MSEL | PLL1CFG_PSEL;	// Ajustando o multiplicador e divisor do PLL
    1302:	602e      	str	r6, [r5, #0]
  	PLL1FEED = 0xAA;	PLL1FEED = 0x55;	// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG
    1304:	601c      	str	r4, [r3, #0]
    1306:	6018      	str	r0, [r3, #0]
  	pll1_ON();								// Habilita PLL
    1308:	6815      	ldr	r5, [r2, #0]
    130a:	f045 0501 	orr.w	r5, r5, #1
    130e:	6015      	str	r5, [r2, #0]
  	PLL1FEED = 0xAA;	PLL1FEED = 0x55;	// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG

  	while (!(PLL1STAT & PLL1STAT_LOCK));	// Espera que o PLL trave. No Skyeye não se usa
    1310:	4d20      	ldr	r5, [pc, #128]	; (1394 <arm_Init+0x12c>)
  	pll1_OFF(); 							// Desabilita PLL
  	PLL1FEED = 0xAA;	PLL1FEED = 0x55;	// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG
  	PLL1CFG = PLL1CFG_MSEL | PLL1CFG_PSEL;	// Ajustando o multiplicador e divisor do PLL
  	PLL1FEED = 0xAA;	PLL1FEED = 0x55;	// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG
  	pll1_ON();								// Habilita PLL
  	PLL1FEED = 0xAA;	PLL1FEED = 0x55;	// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG
    1312:	601c      	str	r4, [r3, #0]
    1314:	6018      	str	r0, [r3, #0]

  	while (!(PLL1STAT & PLL1STAT_LOCK));	// Espera que o PLL trave. No Skyeye não se usa
    1316:	6828      	ldr	r0, [r5, #0]
    1318:	4c1e      	ldr	r4, [pc, #120]	; (1394 <arm_Init+0x12c>)
    131a:	f410 6f80 	tst.w	r0, #1024	; 0x400
    131e:	d0fa      	beq.n	1316 <arm_Init+0xae>
  	#if defined(LPC1751) || defined(LPC1752)
  	pll1_Connect();							// Conecta PLL
    1320:	6810      	ldr	r0, [r2, #0]
    1322:	f040 0002 	orr.w	r0, r0, #2
    1326:	6010      	str	r0, [r2, #0]
  	PLL1FEED = 0xAA;	PLL1FEED = 0x55;	// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG
    1328:	22aa      	movs	r2, #170	; 0xaa
    132a:	601a      	str	r2, [r3, #0]
    132c:	2255      	movs	r2, #85	; 0x55
    132e:	601a      	str	r2, [r3, #0]
	while (!(PLL1STAT & PLL1STAT_PLLC));	// Espera que o PLL se conecte ao sistema
    1330:	6823      	ldr	r3, [r4, #0]
    1332:	059b      	lsls	r3, r3, #22
    1334:	d5fc      	bpl.n	1330 <arm_Init+0xc8>
  	#endif
  	usbksel_clkDiv(USBCLKDIV);				// Aplicar divisor obter o USBCLK do PLL1_OUT
    1336:	4a18      	ldr	r2, [pc, #96]	; (1398 <arm_Init+0x130>)
    1338:	6813      	ldr	r3, [r2, #0]
    133a:	f023 030f 	bic.w	r3, r3, #15
    133e:	f043 0301 	orr.w	r3, r3, #1
    1342:	6013      	str	r3, [r2, #0]
  	#endif

  	cclksel_clkDiv(CCLKDIV);				// Aplicar divisor obter o CCLK do PLL_OUT
    1344:	680b      	ldr	r3, [r1, #0]
    1346:	f023 03ff 	bic.w	r3, r3, #255	; 0xff
    134a:	f043 0302 	orr.w	r3, r3, #2
    134e:	600b      	str	r3, [r1, #0]
		// Pclk roda 1/2 da velocidade do clock da CPU (Cclk)
	  	PCLKSEL  = 0xaaa2a2aa;
  		PCLKSEL1 = 0xa8aaa8aa;
	#elif ((CCLK / PCLK) == 4)
		// Pclk roda 1/4 da velocidade do clock da CPU (Cclk)
	  	PCLKSEL = 0x0;
    1350:	2300      	movs	r3, #0
    1352:	f8c2 30a0 	str.w	r3, [r2, #160]	; 0xa0
  		PCLKSEL1 = 0x0;
    1356:	f8c2 30a4 	str.w	r3, [r2, #164]	; 0xa4
	// O power boost (PBOOST) é ativado após o reset, permitindo trabalhar com frequencia da CPU de até
	//	seu limite máximo. Vamos deixar desse modo, mas se usar gestão de economia de energia teremos
	//	que rever isto
	#if (FLASHTIM == FLASHTIM_AUTO)
		#if (CCLK >= 100000000)
		FLASHCFG = FLASHTIM_100MHZ | 0x3a; // definir a velocidade de acesso a flash (consulte _config_cpu_.h)
    135a:	f244 023a 	movw	r2, #16442	; 0x403a
    135e:	4b0f      	ldr	r3, [pc, #60]	; (139c <arm_Init+0x134>)
    1360:	601a      	str	r2, [r3, #0]
    1362:	bd70      	pop	{r4, r5, r6, pc}
    1364:	e000ed08 	.word	0xe000ed08
    1368:	400fc0c4 	.word	0x400fc0c4
    136c:	400fc104 	.word	0x400fc104
    1370:	400fc10c 	.word	0x400fc10c
    1374:	400fc1a0 	.word	0x400fc1a0
    1378:	400fc080 	.word	0x400fc080
    137c:	400fc084 	.word	0x400fc084
    1380:	400fc08c 	.word	0x400fc08c
    1384:	400fc088 	.word	0x400fc088
    1388:	400fc0a0 	.word	0x400fc0a0
    138c:	400fc0a4 	.word	0x400fc0a4
    1390:	400fc0ac 	.word	0x400fc0ac
    1394:	400fc0a8 	.word	0x400fc0a8
    1398:	400fc108 	.word	0x400fc108
    139c:	400fc000 	.word	0x400fc000

Disassembly of section .text._start:

000013a0 <_start>:
#endif


// ESTA FUNÇÃO É CHAMADA PELO VETOR DE INTERRUPÇÃO RESET
void _start (void);
void _start (void) {
    13a0:	b508      	push	{r3, lr}
	// DESABILITA TODAS AS INTERRUPÇÕES
	irq_Disable();
    13a2:	b672      	cpsid	i
	// -------------------------------------------------------------------------------------------------------------------------
	// CONFIGURA PROCESSADOR ARM
	// 	As configurações do arm deve ser feita antes, isto porque em algumas configurações abaixo
	//	 necessitam de delays para inicializações baseadas na frequencia do processador
	// -------------------------------------------------------------------------------------------------------------------------
	arm_Init();
    13a4:	f7ff ff60 	bl	1268 <arm_Init>
    13a8:	4a0a      	ldr	r2, [pc, #40]	; (13d4 <_start+0x34>)
    13aa:	4b0b      	ldr	r3, [pc, #44]	; (13d8 <_start+0x38>)
	// ATRIBUI OS VALORES INICIAIS DAS VARIÁVEIS DA SECÇÃO .data
	// -------------------------------------------------------------------------------------------------------------------------
	#if defined(RUN_MODE1) || defined(RUN_MODE2) || defined (RUN_MODEBOOT1) || defined (RUN_MODEBOOT2)
	pSrc  = &_etext; 		// Captura o endereço final da secção .text e .rodata. Onde contém os valores da variáveis inicializadas
	pDest = &_data;			// Captura o endereço inicial da área de RAM da secção .data (variáveis inicializadas)
	while(pDest < &_edata)	// Faça até o endereço final da área de RAM da secção .data
    13ac:	490b      	ldr	r1, [pc, #44]	; (13dc <_start+0x3c>)
    13ae:	428b      	cmp	r3, r1
    13b0:	d204      	bcs.n	13bc <_start+0x1c>
		*pDest++ = *pSrc++;
    13b2:	f852 0f04 	ldr.w	r0, [r2, #4]!
    13b6:	f843 0b04 	str.w	r0, [r3], #4
    13ba:	e7f8      	b.n	13ae <_start+0xe>
    13bc:	4b08      	ldr	r3, [pc, #32]	; (13e0 <_start+0x40>)

	// -------------------------------------------------------------------------------------------------------------------------
	// LIMPA A ÁREA DE RAM DAS VARIÁVEIS NÃO INICIALIZADAS
	// -------------------------------------------------------------------------------------------------------------------------
	pDest = &_bss; 			// Captura o endereço inicial da área de RAM da secção .bss (variáveis não inicializadas)
	while(pDest < &_ebss)	// Faça até o endereço final da área de RAM da secção .bss
    13be:	4a09      	ldr	r2, [pc, #36]	; (13e4 <_start+0x44>)
		*pDest++ = 0;		// Limpa o endereço de memória
    13c0:	2100      	movs	r1, #0

	// -------------------------------------------------------------------------------------------------------------------------
	// LIMPA A ÁREA DE RAM DAS VARIÁVEIS NÃO INICIALIZADAS
	// -------------------------------------------------------------------------------------------------------------------------
	pDest = &_bss; 			// Captura o endereço inicial da área de RAM da secção .bss (variáveis não inicializadas)
	while(pDest < &_ebss)	// Faça até o endereço final da área de RAM da secção .bss
    13c2:	4293      	cmp	r3, r2
    13c4:	d202      	bcs.n	13cc <_start+0x2c>
		*pDest++ = 0;		// Limpa o endereço de memória
    13c6:	f843 1b04 	str.w	r1, [r3], #4
    13ca:	e7fa      	b.n	13c2 <_start+0x22>


	// -------------------------------------------------------------------------------------------------------------------------
	// CHAMA O PROGRAMA MAIN SEM PASSAGEM DE PARAMETROS
	// -------------------------------------------------------------------------------------------------------------------------
	main();
    13cc:	f000 fe04 	bl	1fd8 <main>
    13d0:	e7fe      	b.n	13d0 <_start+0x30>
    13d2:	bf00      	nop
    13d4:	0000a7cc 	.word	0x0000a7cc
    13d8:	10000000 	.word	0x10000000
    13dc:	100005dc 	.word	0x100005dc
    13e0:	100005dc 	.word	0x100005dc
    13e4:	10000884 	.word	0x10000884

Disassembly of section .text.nmi_ISR:

000013e8 <nmi_ISR>:
}; /* gVectors */

/*
 * And here are the weak interrupt handlers.
 */
void nmi_ISR (void) {
    13e8:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr NMI");
    13ea:	4905      	ldr	r1, [pc, #20]	; (1400 <nmi_ISR+0x18>)
    13ec:	2002      	movs	r0, #2
    13ee:	f001 fee9 	bl	31c4 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(1);
    13f2:	4b04      	ldr	r3, [pc, #16]	; (1404 <nmi_ISR+0x1c>)
    13f4:	681a      	ldr	r2, [r3, #0]
    13f6:	b112      	cbz	r2, 13fe <nmi_ISR+0x16>
    13f8:	681b      	ldr	r3, [r3, #0]
    13fa:	2001      	movs	r0, #1
    13fc:	4798      	blx	r3
    13fe:	e7fe      	b.n	13fe <nmi_ISR+0x16>
    1400:	00004b78 	.word	0x00004b78
    1404:	100005fc 	.word	0x100005fc

Disassembly of section .text.hardFault_ISR:

00001408 <hardFault_ISR>:
	while(1);
}

void hardFault_ISR (void) {
    1408:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr hardFault"CMD_TERMINATOR);
    140a:	490d      	ldr	r1, [pc, #52]	; (1440 <hardFault_ISR+0x38>)
    140c:	2002      	movs	r0, #2
    140e:	f001 fed9 	bl	31c4 <rprintf>
	plognp("Possiveis causas:"CMD_TERMINATOR);
    1412:	490c      	ldr	r1, [pc, #48]	; (1444 <hardFault_ISR+0x3c>)
    1414:	2002      	movs	r0, #2
    1416:	f001 fed5 	bl	31c4 <rprintf>
	plognp("  Acesso a um hardware não ligado ou com clock desligado"CMD_TERMINATOR);
    141a:	490b      	ldr	r1, [pc, #44]	; (1448 <hardFault_ISR+0x40>)
    141c:	2002      	movs	r0, #2
    141e:	f001 fed1 	bl	31c4 <rprintf>
	plognp("  Acesso a memória inexistente"CMD_TERMINATOR);
    1422:	490a      	ldr	r1, [pc, #40]	; (144c <hardFault_ISR+0x44>)
    1424:	2002      	movs	r0, #2
    1426:	f001 fecd 	bl	31c4 <rprintf>
	plognp("  Registrador acessando pino I/O apontando para duas funções diferentes"CMD_TERMINATOR);
    142a:	4909      	ldr	r1, [pc, #36]	; (1450 <hardFault_ISR+0x48>)
    142c:	2002      	movs	r0, #2
    142e:	f001 fec9 	bl	31c4 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(2);
    1432:	4b08      	ldr	r3, [pc, #32]	; (1454 <hardFault_ISR+0x4c>)
    1434:	681a      	ldr	r2, [r3, #0]
    1436:	b112      	cbz	r2, 143e <hardFault_ISR+0x36>
    1438:	681b      	ldr	r3, [r3, #0]
    143a:	2002      	movs	r0, #2
    143c:	4798      	blx	r3
    143e:	e7fe      	b.n	143e <hardFault_ISR+0x36>
    1440:	00004b83 	.word	0x00004b83
    1444:	00004b95 	.word	0x00004b95
    1448:	00004ba8 	.word	0x00004ba8
    144c:	00004be2 	.word	0x00004be2
    1450:	00004c02 	.word	0x00004c02
    1454:	100005fc 	.word	0x100005fc

Disassembly of section .text.memManage_ISR:

00001458 <memManage_ISR>:
	while(1);
}
void memManage_ISR (void) {
    1458:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr memManage");
    145a:	4905      	ldr	r1, [pc, #20]	; (1470 <memManage_ISR+0x18>)
    145c:	2002      	movs	r0, #2
    145e:	f001 feb1 	bl	31c4 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(3);
    1462:	4b04      	ldr	r3, [pc, #16]	; (1474 <memManage_ISR+0x1c>)
    1464:	681a      	ldr	r2, [r3, #0]
    1466:	b112      	cbz	r2, 146e <memManage_ISR+0x16>
    1468:	681b      	ldr	r3, [r3, #0]
    146a:	2003      	movs	r0, #3
    146c:	4798      	blx	r3
    146e:	e7fe      	b.n	146e <memManage_ISR+0x16>
    1470:	00004c4b 	.word	0x00004c4b
    1474:	100005fc 	.word	0x100005fc

Disassembly of section .text.busFault_ISR:

00001478 <busFault_ISR>:
	while(1);
}
void busFault_ISR (void) {
    1478:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr busFault");
    147a:	4905      	ldr	r1, [pc, #20]	; (1490 <busFault_ISR+0x18>)
    147c:	2002      	movs	r0, #2
    147e:	f001 fea1 	bl	31c4 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(4);
    1482:	4b04      	ldr	r3, [pc, #16]	; (1494 <busFault_ISR+0x1c>)
    1484:	681a      	ldr	r2, [r3, #0]
    1486:	b112      	cbz	r2, 148e <busFault_ISR+0x16>
    1488:	681b      	ldr	r3, [r3, #0]
    148a:	2004      	movs	r0, #4
    148c:	4798      	blx	r3
    148e:	e7fe      	b.n	148e <busFault_ISR+0x16>
    1490:	00004c5c 	.word	0x00004c5c
    1494:	100005fc 	.word	0x100005fc

Disassembly of section .text.usageFault_ISR:

00001498 <usageFault_ISR>:
	while(1);
}
void usageFault_ISR (void) {
    1498:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr usageFault_ISR");
    149a:	4905      	ldr	r1, [pc, #20]	; (14b0 <usageFault_ISR+0x18>)
    149c:	2002      	movs	r0, #2
    149e:	f001 fe91 	bl	31c4 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(5);
    14a2:	4b04      	ldr	r3, [pc, #16]	; (14b4 <usageFault_ISR+0x1c>)
    14a4:	681a      	ldr	r2, [r3, #0]
    14a6:	b112      	cbz	r2, 14ae <usageFault_ISR+0x16>
    14a8:	681b      	ldr	r3, [r3, #0]
    14aa:	2005      	movs	r0, #5
    14ac:	4798      	blx	r3
    14ae:	e7fe      	b.n	14ae <usageFault_ISR+0x16>
    14b0:	00004c6c 	.word	0x00004c6c
    14b4:	100005fc 	.word	0x100005fc

Disassembly of section .text.svc_ISR:

000014b8 <svc_ISR>:
	while(1);
}
void svc_ISR (void) {
    14b8:	b508      	push	{r3, lr}
#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr svc");
    14ba:	4905      	ldr	r1, [pc, #20]	; (14d0 <svc_ISR+0x18>)
    14bc:	2002      	movs	r0, #2
    14be:	f001 fe81 	bl	31c4 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(6);
    14c2:	4b04      	ldr	r3, [pc, #16]	; (14d4 <svc_ISR+0x1c>)
    14c4:	681a      	ldr	r2, [r3, #0]
    14c6:	b112      	cbz	r2, 14ce <svc_ISR+0x16>
    14c8:	681b      	ldr	r3, [r3, #0]
    14ca:	2006      	movs	r0, #6
    14cc:	4798      	blx	r3
    14ce:	e7fe      	b.n	14ce <svc_ISR+0x16>
    14d0:	00004c82 	.word	0x00004c82
    14d4:	100005fc 	.word	0x100005fc

Disassembly of section .text.debugMon_ISR:

000014d8 <debugMon_ISR>:
	while(1);
}
void debugMon_ISR (void) {
    14d8:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr debugMon");
    14da:	4905      	ldr	r1, [pc, #20]	; (14f0 <debugMon_ISR+0x18>)
    14dc:	2002      	movs	r0, #2
    14de:	f001 fe71 	bl	31c4 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(7);
    14e2:	4b04      	ldr	r3, [pc, #16]	; (14f4 <debugMon_ISR+0x1c>)
    14e4:	681a      	ldr	r2, [r3, #0]
    14e6:	b112      	cbz	r2, 14ee <debugMon_ISR+0x16>
    14e8:	681b      	ldr	r3, [r3, #0]
    14ea:	2007      	movs	r0, #7
    14ec:	4798      	blx	r3
    14ee:	e7fe      	b.n	14ee <debugMon_ISR+0x16>
    14f0:	00004c8d 	.word	0x00004c8d
    14f4:	100005fc 	.word	0x100005fc

Disassembly of section .text.pendSV_ISR:

000014f8 <pendSV_ISR>:
	while(1);
}
void pendSV_ISR (void) {
    14f8:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr pendSV");
    14fa:	4905      	ldr	r1, [pc, #20]	; (1510 <pendSV_ISR+0x18>)
    14fc:	2002      	movs	r0, #2
    14fe:	f001 fe61 	bl	31c4 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(8);
    1502:	4b04      	ldr	r3, [pc, #16]	; (1514 <pendSV_ISR+0x1c>)
    1504:	681a      	ldr	r2, [r3, #0]
    1506:	b112      	cbz	r2, 150e <pendSV_ISR+0x16>
    1508:	681b      	ldr	r3, [r3, #0]
    150a:	2008      	movs	r0, #8
    150c:	4798      	blx	r3
    150e:	e7fe      	b.n	150e <pendSV_ISR+0x16>
    1510:	00004c9d 	.word	0x00004c9d
    1514:	100005fc 	.word	0x100005fc

Disassembly of section .text.wdt_ISR:

00001518 <wdt_ISR>:
	plognp("vicErr sysTick");
	#endif
	if (vicerr_Functions) vicerr_Functions(9);
	while(1);
}
void wdt_ISR (void) {
    1518:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr wdt");
    151a:	4905      	ldr	r1, [pc, #20]	; (1530 <wdt_ISR+0x18>)
    151c:	2002      	movs	r0, #2
    151e:	f001 fe51 	bl	31c4 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(10);
    1522:	4b04      	ldr	r3, [pc, #16]	; (1534 <wdt_ISR+0x1c>)
    1524:	681a      	ldr	r2, [r3, #0]
    1526:	b112      	cbz	r2, 152e <wdt_ISR+0x16>
    1528:	681b      	ldr	r3, [r3, #0]
    152a:	200a      	movs	r0, #10
    152c:	4798      	blx	r3
    152e:	e7fe      	b.n	152e <wdt_ISR+0x16>
    1530:	00004cba 	.word	0x00004cba
    1534:	100005fc 	.word	0x100005fc

Disassembly of section .text.timer0_ISR:

00001538 <timer0_ISR>:
	while(1);
}
void timer0_ISR (void) {
    1538:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr timer0");
    153a:	4905      	ldr	r1, [pc, #20]	; (1550 <timer0_ISR+0x18>)
    153c:	2002      	movs	r0, #2
    153e:	f001 fe41 	bl	31c4 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(11);
    1542:	4b04      	ldr	r3, [pc, #16]	; (1554 <timer0_ISR+0x1c>)
    1544:	681a      	ldr	r2, [r3, #0]
    1546:	b112      	cbz	r2, 154e <timer0_ISR+0x16>
    1548:	681b      	ldr	r3, [r3, #0]
    154a:	200b      	movs	r0, #11
    154c:	4798      	blx	r3
    154e:	e7fe      	b.n	154e <timer0_ISR+0x16>
    1550:	00004cc5 	.word	0x00004cc5
    1554:	100005fc 	.word	0x100005fc

Disassembly of section .text.timer1_ISR:

00001558 <timer1_ISR>:
	while(1);
}
void timer1_ISR (void) {
    1558:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr timer1");
    155a:	4905      	ldr	r1, [pc, #20]	; (1570 <timer1_ISR+0x18>)
    155c:	2002      	movs	r0, #2
    155e:	f001 fe31 	bl	31c4 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(12);
    1562:	4b04      	ldr	r3, [pc, #16]	; (1574 <timer1_ISR+0x1c>)
    1564:	681a      	ldr	r2, [r3, #0]
    1566:	b112      	cbz	r2, 156e <timer1_ISR+0x16>
    1568:	681b      	ldr	r3, [r3, #0]
    156a:	200c      	movs	r0, #12
    156c:	4798      	blx	r3
    156e:	e7fe      	b.n	156e <timer1_ISR+0x16>
    1570:	00004cd3 	.word	0x00004cd3
    1574:	100005fc 	.word	0x100005fc

Disassembly of section .text.timer2_ISR:

00001578 <timer2_ISR>:
	while(1);
}
void timer2_ISR (void) {
    1578:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr timer2");
    157a:	4905      	ldr	r1, [pc, #20]	; (1590 <timer2_ISR+0x18>)
    157c:	2002      	movs	r0, #2
    157e:	f001 fe21 	bl	31c4 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(13);
    1582:	4b04      	ldr	r3, [pc, #16]	; (1594 <timer2_ISR+0x1c>)
    1584:	681a      	ldr	r2, [r3, #0]
    1586:	b112      	cbz	r2, 158e <timer2_ISR+0x16>
    1588:	681b      	ldr	r3, [r3, #0]
    158a:	200d      	movs	r0, #13
    158c:	4798      	blx	r3
    158e:	e7fe      	b.n	158e <timer2_ISR+0x16>
    1590:	00004ce1 	.word	0x00004ce1
    1594:	100005fc 	.word	0x100005fc

Disassembly of section .text.timer3_ISR:

00001598 <timer3_ISR>:
	while(1);
}
void timer3_ISR (void) {
    1598:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr timer3");
    159a:	4905      	ldr	r1, [pc, #20]	; (15b0 <timer3_ISR+0x18>)
    159c:	2002      	movs	r0, #2
    159e:	f001 fe11 	bl	31c4 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(14);
    15a2:	4b04      	ldr	r3, [pc, #16]	; (15b4 <timer3_ISR+0x1c>)
    15a4:	681a      	ldr	r2, [r3, #0]
    15a6:	b112      	cbz	r2, 15ae <timer3_ISR+0x16>
    15a8:	681b      	ldr	r3, [r3, #0]
    15aa:	200e      	movs	r0, #14
    15ac:	4798      	blx	r3
    15ae:	e7fe      	b.n	15ae <timer3_ISR+0x16>
    15b0:	00004cef 	.word	0x00004cef
    15b4:	100005fc 	.word	0x100005fc

Disassembly of section .text.uart1_ISR:

000015b8 <uart1_ISR>:
	plognp("vicErr uart0");
	#endif
	if (vicerr_Functions) vicerr_Functions(15);
	while(1);
}
void uart1_ISR (void) {
    15b8:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr uart1");
    15ba:	4905      	ldr	r1, [pc, #20]	; (15d0 <uart1_ISR+0x18>)
    15bc:	2002      	movs	r0, #2
    15be:	f001 fe01 	bl	31c4 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(16);
    15c2:	4b04      	ldr	r3, [pc, #16]	; (15d4 <uart1_ISR+0x1c>)
    15c4:	681a      	ldr	r2, [r3, #0]
    15c6:	b112      	cbz	r2, 15ce <uart1_ISR+0x16>
    15c8:	681b      	ldr	r3, [r3, #0]
    15ca:	2010      	movs	r0, #16
    15cc:	4798      	blx	r3
    15ce:	e7fe      	b.n	15ce <uart1_ISR+0x16>
    15d0:	00004d0a 	.word	0x00004d0a
    15d4:	100005fc 	.word	0x100005fc

Disassembly of section .text.uart2_ISR:

000015d8 <uart2_ISR>:
	while(1);
}
void uart2_ISR (void) {
    15d8:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr uart2");
    15da:	4905      	ldr	r1, [pc, #20]	; (15f0 <uart2_ISR+0x18>)
    15dc:	2002      	movs	r0, #2
    15de:	f001 fdf1 	bl	31c4 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(17);
    15e2:	4b04      	ldr	r3, [pc, #16]	; (15f4 <uart2_ISR+0x1c>)
    15e4:	681a      	ldr	r2, [r3, #0]
    15e6:	b112      	cbz	r2, 15ee <uart2_ISR+0x16>
    15e8:	681b      	ldr	r3, [r3, #0]
    15ea:	2011      	movs	r0, #17
    15ec:	4798      	blx	r3
    15ee:	e7fe      	b.n	15ee <uart2_ISR+0x16>
    15f0:	00004d17 	.word	0x00004d17
    15f4:	100005fc 	.word	0x100005fc

Disassembly of section .text.uart3_ISR:

000015f8 <uart3_ISR>:
	while(1);
}
void uart3_ISR (void) {
    15f8:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr uart3");
    15fa:	4905      	ldr	r1, [pc, #20]	; (1610 <uart3_ISR+0x18>)
    15fc:	2002      	movs	r0, #2
    15fe:	f001 fde1 	bl	31c4 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(18);
    1602:	4b04      	ldr	r3, [pc, #16]	; (1614 <uart3_ISR+0x1c>)
    1604:	681a      	ldr	r2, [r3, #0]
    1606:	b112      	cbz	r2, 160e <uart3_ISR+0x16>
    1608:	681b      	ldr	r3, [r3, #0]
    160a:	2012      	movs	r0, #18
    160c:	4798      	blx	r3
    160e:	e7fe      	b.n	160e <uart3_ISR+0x16>
    1610:	00004d24 	.word	0x00004d24
    1614:	100005fc 	.word	0x100005fc

Disassembly of section .text.pwm_ISR:

00001618 <pwm_ISR>:
	while(1);
}
void pwm_ISR (void) {
    1618:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr pwm");
    161a:	4905      	ldr	r1, [pc, #20]	; (1630 <pwm_ISR+0x18>)
    161c:	2002      	movs	r0, #2
    161e:	f001 fdd1 	bl	31c4 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(19);
    1622:	4b04      	ldr	r3, [pc, #16]	; (1634 <pwm_ISR+0x1c>)
    1624:	681a      	ldr	r2, [r3, #0]
    1626:	b112      	cbz	r2, 162e <pwm_ISR+0x16>
    1628:	681b      	ldr	r3, [r3, #0]
    162a:	2013      	movs	r0, #19
    162c:	4798      	blx	r3
    162e:	e7fe      	b.n	162e <pwm_ISR+0x16>
    1630:	00004d31 	.word	0x00004d31
    1634:	100005fc 	.word	0x100005fc

Disassembly of section .text.i2c0_ISR:

00001638 <i2c0_ISR>:
	while(1);
}
void i2c0_ISR (void) {
    1638:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr i2c0");
    163a:	4905      	ldr	r1, [pc, #20]	; (1650 <i2c0_ISR+0x18>)
    163c:	2002      	movs	r0, #2
    163e:	f001 fdc1 	bl	31c4 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(20);
    1642:	4b04      	ldr	r3, [pc, #16]	; (1654 <i2c0_ISR+0x1c>)
    1644:	681a      	ldr	r2, [r3, #0]
    1646:	b112      	cbz	r2, 164e <i2c0_ISR+0x16>
    1648:	681b      	ldr	r3, [r3, #0]
    164a:	2014      	movs	r0, #20
    164c:	4798      	blx	r3
    164e:	e7fe      	b.n	164e <i2c0_ISR+0x16>
    1650:	00004d3c 	.word	0x00004d3c
    1654:	100005fc 	.word	0x100005fc

Disassembly of section .text.i2c1_ISR:

00001658 <i2c1_ISR>:
	while(1);
}
void i2c1_ISR (void) {
    1658:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr i2c1");
    165a:	4905      	ldr	r1, [pc, #20]	; (1670 <i2c1_ISR+0x18>)
    165c:	2002      	movs	r0, #2
    165e:	f001 fdb1 	bl	31c4 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(21);
    1662:	4b04      	ldr	r3, [pc, #16]	; (1674 <i2c1_ISR+0x1c>)
    1664:	681a      	ldr	r2, [r3, #0]
    1666:	b112      	cbz	r2, 166e <i2c1_ISR+0x16>
    1668:	681b      	ldr	r3, [r3, #0]
    166a:	2015      	movs	r0, #21
    166c:	4798      	blx	r3
    166e:	e7fe      	b.n	166e <i2c1_ISR+0x16>
    1670:	00004d48 	.word	0x00004d48
    1674:	100005fc 	.word	0x100005fc

Disassembly of section .text.i2c2_ISR:

00001678 <i2c2_ISR>:
	while(1);
}
void i2c2_ISR (void) {
    1678:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr i2c2");
    167a:	4905      	ldr	r1, [pc, #20]	; (1690 <i2c2_ISR+0x18>)
    167c:	2002      	movs	r0, #2
    167e:	f001 fda1 	bl	31c4 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(22);
    1682:	4b04      	ldr	r3, [pc, #16]	; (1694 <i2c2_ISR+0x1c>)
    1684:	681a      	ldr	r2, [r3, #0]
    1686:	b112      	cbz	r2, 168e <i2c2_ISR+0x16>
    1688:	681b      	ldr	r3, [r3, #0]
    168a:	2016      	movs	r0, #22
    168c:	4798      	blx	r3
    168e:	e7fe      	b.n	168e <i2c2_ISR+0x16>
    1690:	00004d54 	.word	0x00004d54
    1694:	100005fc 	.word	0x100005fc

Disassembly of section .text.spi_ISR:

00001698 <spi_ISR>:
	while(1);
}
void spi_ISR (void) {
    1698:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr spi");
    169a:	4905      	ldr	r1, [pc, #20]	; (16b0 <spi_ISR+0x18>)
    169c:	2002      	movs	r0, #2
    169e:	f001 fd91 	bl	31c4 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(23);
    16a2:	4b04      	ldr	r3, [pc, #16]	; (16b4 <spi_ISR+0x1c>)
    16a4:	681a      	ldr	r2, [r3, #0]
    16a6:	b112      	cbz	r2, 16ae <spi_ISR+0x16>
    16a8:	681b      	ldr	r3, [r3, #0]
    16aa:	2017      	movs	r0, #23
    16ac:	4798      	blx	r3
    16ae:	e7fe      	b.n	16ae <spi_ISR+0x16>
    16b0:	00004d60 	.word	0x00004d60
    16b4:	100005fc 	.word	0x100005fc

Disassembly of section .text.ssp0_ISR:

000016b8 <ssp0_ISR>:
	while(1);
}
void ssp0_ISR (void) {
    16b8:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr spp0");
    16ba:	4905      	ldr	r1, [pc, #20]	; (16d0 <ssp0_ISR+0x18>)
    16bc:	2002      	movs	r0, #2
    16be:	f001 fd81 	bl	31c4 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(24);
    16c2:	4b04      	ldr	r3, [pc, #16]	; (16d4 <ssp0_ISR+0x1c>)
    16c4:	681a      	ldr	r2, [r3, #0]
    16c6:	b112      	cbz	r2, 16ce <ssp0_ISR+0x16>
    16c8:	681b      	ldr	r3, [r3, #0]
    16ca:	2018      	movs	r0, #24
    16cc:	4798      	blx	r3
    16ce:	e7fe      	b.n	16ce <ssp0_ISR+0x16>
    16d0:	00004d6b 	.word	0x00004d6b
    16d4:	100005fc 	.word	0x100005fc

Disassembly of section .text.ssp1_ISR:

000016d8 <ssp1_ISR>:
	while(1);
}
void ssp1_ISR (void) {
    16d8:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr spp1");
    16da:	4905      	ldr	r1, [pc, #20]	; (16f0 <ssp1_ISR+0x18>)
    16dc:	2002      	movs	r0, #2
    16de:	f001 fd71 	bl	31c4 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(25);
    16e2:	4b04      	ldr	r3, [pc, #16]	; (16f4 <ssp1_ISR+0x1c>)
    16e4:	681a      	ldr	r2, [r3, #0]
    16e6:	b112      	cbz	r2, 16ee <ssp1_ISR+0x16>
    16e8:	681b      	ldr	r3, [r3, #0]
    16ea:	2019      	movs	r0, #25
    16ec:	4798      	blx	r3
    16ee:	e7fe      	b.n	16ee <ssp1_ISR+0x16>
    16f0:	00004d77 	.word	0x00004d77
    16f4:	100005fc 	.word	0x100005fc

Disassembly of section .text.pll0_ISR:

000016f8 <pll0_ISR>:
	while(1);
}
void pll0_ISR (void) {
    16f8:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr pll0");
    16fa:	4905      	ldr	r1, [pc, #20]	; (1710 <pll0_ISR+0x18>)
    16fc:	2002      	movs	r0, #2
    16fe:	f001 fd61 	bl	31c4 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(26);
    1702:	4b04      	ldr	r3, [pc, #16]	; (1714 <pll0_ISR+0x1c>)
    1704:	681a      	ldr	r2, [r3, #0]
    1706:	b112      	cbz	r2, 170e <pll0_ISR+0x16>
    1708:	681b      	ldr	r3, [r3, #0]
    170a:	201a      	movs	r0, #26
    170c:	4798      	blx	r3
    170e:	e7fe      	b.n	170e <pll0_ISR+0x16>
    1710:	00004d83 	.word	0x00004d83
    1714:	100005fc 	.word	0x100005fc

Disassembly of section .text.rtc_ISR:

00001718 <rtc_ISR>:
	while(1);
}
void rtc_ISR (void) {
    1718:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr ");
    171a:	4905      	ldr	r1, [pc, #20]	; (1730 <rtc_ISR+0x18>)
    171c:	2002      	movs	r0, #2
    171e:	f001 fd51 	bl	31c4 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(27);
    1722:	4b04      	ldr	r3, [pc, #16]	; (1734 <rtc_ISR+0x1c>)
    1724:	681a      	ldr	r2, [r3, #0]
    1726:	b112      	cbz	r2, 172e <rtc_ISR+0x16>
    1728:	681b      	ldr	r3, [r3, #0]
    172a:	201b      	movs	r0, #27
    172c:	4798      	blx	r3
    172e:	e7fe      	b.n	172e <rtc_ISR+0x16>
    1730:	00004d8f 	.word	0x00004d8f
    1734:	100005fc 	.word	0x100005fc

Disassembly of section .text.eint0_ISR:

00001738 <eint0_ISR>:
	while(1);
}
void eint0_ISR (void) {
    1738:	b508      	push	{r3, lr}
#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr eint0");
    173a:	4905      	ldr	r1, [pc, #20]	; (1750 <eint0_ISR+0x18>)
    173c:	2002      	movs	r0, #2
    173e:	f001 fd41 	bl	31c4 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(28);
    1742:	4b04      	ldr	r3, [pc, #16]	; (1754 <eint0_ISR+0x1c>)
    1744:	681a      	ldr	r2, [r3, #0]
    1746:	b112      	cbz	r2, 174e <eint0_ISR+0x16>
    1748:	681b      	ldr	r3, [r3, #0]
    174a:	201c      	movs	r0, #28
    174c:	4798      	blx	r3
    174e:	e7fe      	b.n	174e <eint0_ISR+0x16>
    1750:	00004d97 	.word	0x00004d97
    1754:	100005fc 	.word	0x100005fc

Disassembly of section .text.eint1_ISR:

00001758 <eint1_ISR>:
	while(1);
}
void eint1_ISR (void) {
    1758:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr eint1");
    175a:	4905      	ldr	r1, [pc, #20]	; (1770 <eint1_ISR+0x18>)
    175c:	2002      	movs	r0, #2
    175e:	f001 fd31 	bl	31c4 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(29);
    1762:	4b04      	ldr	r3, [pc, #16]	; (1774 <eint1_ISR+0x1c>)
    1764:	681a      	ldr	r2, [r3, #0]
    1766:	b112      	cbz	r2, 176e <eint1_ISR+0x16>
    1768:	681b      	ldr	r3, [r3, #0]
    176a:	201d      	movs	r0, #29
    176c:	4798      	blx	r3
    176e:	e7fe      	b.n	176e <eint1_ISR+0x16>
    1770:	00004da4 	.word	0x00004da4
    1774:	100005fc 	.word	0x100005fc

Disassembly of section .text.eint2_ISR:

00001778 <eint2_ISR>:
	while(1);
}
void eint2_ISR (void) {
    1778:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr eint2");
    177a:	4905      	ldr	r1, [pc, #20]	; (1790 <eint2_ISR+0x18>)
    177c:	2002      	movs	r0, #2
    177e:	f001 fd21 	bl	31c4 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(30);
    1782:	4b04      	ldr	r3, [pc, #16]	; (1794 <eint2_ISR+0x1c>)
    1784:	681a      	ldr	r2, [r3, #0]
    1786:	b112      	cbz	r2, 178e <eint2_ISR+0x16>
    1788:	681b      	ldr	r3, [r3, #0]
    178a:	201e      	movs	r0, #30
    178c:	4798      	blx	r3
    178e:	e7fe      	b.n	178e <eint2_ISR+0x16>
    1790:	00004db1 	.word	0x00004db1
    1794:	100005fc 	.word	0x100005fc

Disassembly of section .text.eint3_ISR:

00001798 <eint3_ISR>:
	while(1);
}
void eint3_ISR (void) {
    1798:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr eint3");
    179a:	4905      	ldr	r1, [pc, #20]	; (17b0 <eint3_ISR+0x18>)
    179c:	2002      	movs	r0, #2
    179e:	f001 fd11 	bl	31c4 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(31);
    17a2:	4b04      	ldr	r3, [pc, #16]	; (17b4 <eint3_ISR+0x1c>)
    17a4:	681a      	ldr	r2, [r3, #0]
    17a6:	b112      	cbz	r2, 17ae <eint3_ISR+0x16>
    17a8:	681b      	ldr	r3, [r3, #0]
    17aa:	201f      	movs	r0, #31
    17ac:	4798      	blx	r3
    17ae:	e7fe      	b.n	17ae <eint3_ISR+0x16>
    17b0:	00004dbe 	.word	0x00004dbe
    17b4:	100005fc 	.word	0x100005fc

Disassembly of section .text.adc_ISR:

000017b8 <adc_ISR>:
	while(1);
}
void adc_ISR (void) {
    17b8:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr adc");
    17ba:	4905      	ldr	r1, [pc, #20]	; (17d0 <adc_ISR+0x18>)
    17bc:	2002      	movs	r0, #2
    17be:	f001 fd01 	bl	31c4 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(32);
    17c2:	4b04      	ldr	r3, [pc, #16]	; (17d4 <adc_ISR+0x1c>)
    17c4:	681a      	ldr	r2, [r3, #0]
    17c6:	b112      	cbz	r2, 17ce <adc_ISR+0x16>
    17c8:	681b      	ldr	r3, [r3, #0]
    17ca:	2020      	movs	r0, #32
    17cc:	4798      	blx	r3
    17ce:	e7fe      	b.n	17ce <adc_ISR+0x16>
    17d0:	00004dcb 	.word	0x00004dcb
    17d4:	100005fc 	.word	0x100005fc

Disassembly of section .text.bod_ISR:

000017d8 <bod_ISR>:
	while(1);
}
void bod_ISR (void) {
    17d8:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr bod");
    17da:	4905      	ldr	r1, [pc, #20]	; (17f0 <bod_ISR+0x18>)
    17dc:	2002      	movs	r0, #2
    17de:	f001 fcf1 	bl	31c4 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(33);
    17e2:	4b04      	ldr	r3, [pc, #16]	; (17f4 <bod_ISR+0x1c>)
    17e4:	681a      	ldr	r2, [r3, #0]
    17e6:	b112      	cbz	r2, 17ee <bod_ISR+0x16>
    17e8:	681b      	ldr	r3, [r3, #0]
    17ea:	2021      	movs	r0, #33	; 0x21
    17ec:	4798      	blx	r3
    17ee:	e7fe      	b.n	17ee <bod_ISR+0x16>
    17f0:	00004dd6 	.word	0x00004dd6
    17f4:	100005fc 	.word	0x100005fc

Disassembly of section .text.usbHost_ISR:

000017f8 <usbHost_ISR>:
	while(1);
}
void usbHost_ISR (void) {
    17f8:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr usb");
    17fa:	4905      	ldr	r1, [pc, #20]	; (1810 <usbHost_ISR+0x18>)
    17fc:	2002      	movs	r0, #2
    17fe:	f001 fce1 	bl	31c4 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(34);
    1802:	4b04      	ldr	r3, [pc, #16]	; (1814 <usbHost_ISR+0x1c>)
    1804:	681a      	ldr	r2, [r3, #0]
    1806:	b112      	cbz	r2, 180e <usbHost_ISR+0x16>
    1808:	681b      	ldr	r3, [r3, #0]
    180a:	2022      	movs	r0, #34	; 0x22
    180c:	4798      	blx	r3
    180e:	e7fe      	b.n	180e <usbHost_ISR+0x16>
    1810:	00004de1 	.word	0x00004de1
    1814:	100005fc 	.word	0x100005fc

Disassembly of section .text.can_ISR:

00001818 <can_ISR>:
	while(1);
}
void can_ISR (void) {
    1818:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr can");
    181a:	4905      	ldr	r1, [pc, #20]	; (1830 <can_ISR+0x18>)
    181c:	2002      	movs	r0, #2
    181e:	f001 fcd1 	bl	31c4 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(35);
    1822:	4b04      	ldr	r3, [pc, #16]	; (1834 <can_ISR+0x1c>)
    1824:	681a      	ldr	r2, [r3, #0]
    1826:	b112      	cbz	r2, 182e <can_ISR+0x16>
    1828:	681b      	ldr	r3, [r3, #0]
    182a:	2023      	movs	r0, #35	; 0x23
    182c:	4798      	blx	r3
    182e:	e7fe      	b.n	182e <can_ISR+0x16>
    1830:	00004dec 	.word	0x00004dec
    1834:	100005fc 	.word	0x100005fc

Disassembly of section .text.dma_ISR:

00001838 <dma_ISR>:
	while(1);
}
void dma_ISR (void) {
    1838:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr dma");
    183a:	4905      	ldr	r1, [pc, #20]	; (1850 <dma_ISR+0x18>)
    183c:	2002      	movs	r0, #2
    183e:	f001 fcc1 	bl	31c4 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(36);
    1842:	4b04      	ldr	r3, [pc, #16]	; (1854 <dma_ISR+0x1c>)
    1844:	681a      	ldr	r2, [r3, #0]
    1846:	b112      	cbz	r2, 184e <dma_ISR+0x16>
    1848:	681b      	ldr	r3, [r3, #0]
    184a:	2024      	movs	r0, #36	; 0x24
    184c:	4798      	blx	r3
    184e:	e7fe      	b.n	184e <dma_ISR+0x16>
    1850:	00004df7 	.word	0x00004df7
    1854:	100005fc 	.word	0x100005fc

Disassembly of section .text.i2s_ISR:

00001858 <i2s_ISR>:
	while(1);
}
void i2s_ISR (void) {
    1858:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr i2s");
    185a:	4905      	ldr	r1, [pc, #20]	; (1870 <i2s_ISR+0x18>)
    185c:	2002      	movs	r0, #2
    185e:	f001 fcb1 	bl	31c4 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(37);
    1862:	4b04      	ldr	r3, [pc, #16]	; (1874 <i2s_ISR+0x1c>)
    1864:	681a      	ldr	r2, [r3, #0]
    1866:	b112      	cbz	r2, 186e <i2s_ISR+0x16>
    1868:	681b      	ldr	r3, [r3, #0]
    186a:	2025      	movs	r0, #37	; 0x25
    186c:	4798      	blx	r3
    186e:	e7fe      	b.n	186e <i2s_ISR+0x16>
    1870:	00004e02 	.word	0x00004e02
    1874:	100005fc 	.word	0x100005fc

Disassembly of section .text.enet_ISR:

00001878 <enet_ISR>:
	while(1);
}
void enet_ISR (void) {
    1878:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr enet");
    187a:	4905      	ldr	r1, [pc, #20]	; (1890 <enet_ISR+0x18>)
    187c:	2002      	movs	r0, #2
    187e:	f001 fca1 	bl	31c4 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(38);
    1882:	4b04      	ldr	r3, [pc, #16]	; (1894 <enet_ISR+0x1c>)
    1884:	681a      	ldr	r2, [r3, #0]
    1886:	b112      	cbz	r2, 188e <enet_ISR+0x16>
    1888:	681b      	ldr	r3, [r3, #0]
    188a:	2026      	movs	r0, #38	; 0x26
    188c:	4798      	blx	r3
    188e:	e7fe      	b.n	188e <enet_ISR+0x16>
    1890:	00004e0d 	.word	0x00004e0d
    1894:	100005fc 	.word	0x100005fc

Disassembly of section .text.rit_ISR:

00001898 <rit_ISR>:
	while(1);
}
void rit_ISR (void) {
    1898:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr rit");
    189a:	4905      	ldr	r1, [pc, #20]	; (18b0 <rit_ISR+0x18>)
    189c:	2002      	movs	r0, #2
    189e:	f001 fc91 	bl	31c4 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(39);
    18a2:	4b04      	ldr	r3, [pc, #16]	; (18b4 <rit_ISR+0x1c>)
    18a4:	681a      	ldr	r2, [r3, #0]
    18a6:	b112      	cbz	r2, 18ae <rit_ISR+0x16>
    18a8:	681b      	ldr	r3, [r3, #0]
    18aa:	2027      	movs	r0, #39	; 0x27
    18ac:	4798      	blx	r3
    18ae:	e7fe      	b.n	18ae <rit_ISR+0x16>
    18b0:	00004e19 	.word	0x00004e19
    18b4:	100005fc 	.word	0x100005fc

Disassembly of section .text.mcpwm_ISR:

000018b8 <mcpwm_ISR>:
	while(1);
}
void mcpwm_ISR (void) {
    18b8:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr mcpwm");
    18ba:	4905      	ldr	r1, [pc, #20]	; (18d0 <mcpwm_ISR+0x18>)
    18bc:	2002      	movs	r0, #2
    18be:	f001 fc81 	bl	31c4 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(40);
    18c2:	4b04      	ldr	r3, [pc, #16]	; (18d4 <mcpwm_ISR+0x1c>)
    18c4:	681a      	ldr	r2, [r3, #0]
    18c6:	b112      	cbz	r2, 18ce <mcpwm_ISR+0x16>
    18c8:	681b      	ldr	r3, [r3, #0]
    18ca:	2028      	movs	r0, #40	; 0x28
    18cc:	4798      	blx	r3
    18ce:	e7fe      	b.n	18ce <mcpwm_ISR+0x16>
    18d0:	00004e24 	.word	0x00004e24
    18d4:	100005fc 	.word	0x100005fc

Disassembly of section .text.qei_ISR:

000018d8 <qei_ISR>:
	while(1);
}
void qei_ISR (void) {
    18d8:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr qei");
    18da:	4905      	ldr	r1, [pc, #20]	; (18f0 <qei_ISR+0x18>)
    18dc:	2002      	movs	r0, #2
    18de:	f001 fc71 	bl	31c4 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(41);
    18e2:	4b04      	ldr	r3, [pc, #16]	; (18f4 <qei_ISR+0x1c>)
    18e4:	681a      	ldr	r2, [r3, #0]
    18e6:	b112      	cbz	r2, 18ee <qei_ISR+0x16>
    18e8:	681b      	ldr	r3, [r3, #0]
    18ea:	2029      	movs	r0, #41	; 0x29
    18ec:	4798      	blx	r3
    18ee:	e7fe      	b.n	18ee <qei_ISR+0x16>
    18f0:	00004e31 	.word	0x00004e31
    18f4:	100005fc 	.word	0x100005fc

Disassembly of section .text.pll1_ISR:

000018f8 <pll1_ISR>:
	while(1);
}

void pll1_ISR (void) {
    18f8:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr pll1");
    18fa:	4905      	ldr	r1, [pc, #20]	; (1910 <pll1_ISR+0x18>)
    18fc:	2002      	movs	r0, #2
    18fe:	f001 fc61 	bl	31c4 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(42);
    1902:	4b04      	ldr	r3, [pc, #16]	; (1914 <pll1_ISR+0x1c>)
    1904:	681a      	ldr	r2, [r3, #0]
    1906:	b112      	cbz	r2, 190e <pll1_ISR+0x16>
    1908:	681b      	ldr	r3, [r3, #0]
    190a:	202a      	movs	r0, #42	; 0x2a
    190c:	4798      	blx	r3
    190e:	e7fe      	b.n	190e <pll1_ISR+0x16>
    1910:	00004e3c 	.word	0x00004e3c
    1914:	100005fc 	.word	0x100005fc

Disassembly of section .text.usbAct_ISR:

00001918 <usbAct_ISR>:
	while(1);
}

void usbAct_ISR (void) {
    1918:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr USB ACT");
    191a:	4905      	ldr	r1, [pc, #20]	; (1930 <usbAct_ISR+0x18>)
    191c:	2002      	movs	r0, #2
    191e:	f001 fc51 	bl	31c4 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(43);
    1922:	4b04      	ldr	r3, [pc, #16]	; (1934 <usbAct_ISR+0x1c>)
    1924:	681a      	ldr	r2, [r3, #0]
    1926:	b112      	cbz	r2, 192e <usbAct_ISR+0x16>
    1928:	681b      	ldr	r3, [r3, #0]
    192a:	202b      	movs	r0, #43	; 0x2b
    192c:	4798      	blx	r3
    192e:	e7fe      	b.n	192e <usbAct_ISR+0x16>
    1930:	00004e48 	.word	0x00004e48
    1934:	100005fc 	.word	0x100005fc

Disassembly of section .text.canAct_ISR:

00001938 <canAct_ISR>:
	while(1);
}
void canAct_ISR (void) {
    1938:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr CAN ACT");
    193a:	4905      	ldr	r1, [pc, #20]	; (1950 <canAct_ISR+0x18>)
    193c:	2002      	movs	r0, #2
    193e:	f001 fc41 	bl	31c4 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(44);
    1942:	4b04      	ldr	r3, [pc, #16]	; (1954 <canAct_ISR+0x1c>)
    1944:	681a      	ldr	r2, [r3, #0]
    1946:	b112      	cbz	r2, 194e <canAct_ISR+0x16>
    1948:	681b      	ldr	r3, [r3, #0]
    194a:	202c      	movs	r0, #44	; 0x2c
    194c:	4798      	blx	r3
    194e:	e7fe      	b.n	194e <canAct_ISR+0x16>
    1950:	00004e57 	.word	0x00004e57
    1954:	100005fc 	.word	0x100005fc

Disassembly of section .text.uart4_ISR:

00001958 <uart4_ISR>:
	while(1);
}
void uart4_ISR (void) {
    1958:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr uart4");
    195a:	4905      	ldr	r1, [pc, #20]	; (1970 <uart4_ISR+0x18>)
    195c:	2002      	movs	r0, #2
    195e:	f001 fc31 	bl	31c4 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(45);
    1962:	4b04      	ldr	r3, [pc, #16]	; (1974 <uart4_ISR+0x1c>)
    1964:	681a      	ldr	r2, [r3, #0]
    1966:	b112      	cbz	r2, 196e <uart4_ISR+0x16>
    1968:	681b      	ldr	r3, [r3, #0]
    196a:	202d      	movs	r0, #45	; 0x2d
    196c:	4798      	blx	r3
    196e:	e7fe      	b.n	196e <uart4_ISR+0x16>
    1970:	00004e66 	.word	0x00004e66
    1974:	100005fc 	.word	0x100005fc

Disassembly of section .text.ssp2_ISR:

00001978 <ssp2_ISR>:
	while(1);
}
void ssp2_ISR (void) {
    1978:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr ssp2");
    197a:	4905      	ldr	r1, [pc, #20]	; (1990 <ssp2_ISR+0x18>)
    197c:	2002      	movs	r0, #2
    197e:	f001 fc21 	bl	31c4 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(46);
    1982:	4b04      	ldr	r3, [pc, #16]	; (1994 <ssp2_ISR+0x1c>)
    1984:	681a      	ldr	r2, [r3, #0]
    1986:	b112      	cbz	r2, 198e <ssp2_ISR+0x16>
    1988:	681b      	ldr	r3, [r3, #0]
    198a:	202e      	movs	r0, #46	; 0x2e
    198c:	4798      	blx	r3
    198e:	e7fe      	b.n	198e <ssp2_ISR+0x16>
    1990:	00004e73 	.word	0x00004e73
    1994:	100005fc 	.word	0x100005fc

Disassembly of section .text.lcd_ISR:

00001998 <lcd_ISR>:
	while(1);
}
void lcd_ISR (void) {
    1998:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr lcd");
    199a:	4905      	ldr	r1, [pc, #20]	; (19b0 <lcd_ISR+0x18>)
    199c:	2002      	movs	r0, #2
    199e:	f001 fc11 	bl	31c4 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(47);
    19a2:	4b04      	ldr	r3, [pc, #16]	; (19b4 <lcd_ISR+0x1c>)
    19a4:	681a      	ldr	r2, [r3, #0]
    19a6:	b112      	cbz	r2, 19ae <lcd_ISR+0x16>
    19a8:	681b      	ldr	r3, [r3, #0]
    19aa:	202f      	movs	r0, #47	; 0x2f
    19ac:	4798      	blx	r3
    19ae:	e7fe      	b.n	19ae <lcd_ISR+0x16>
    19b0:	00004e7f 	.word	0x00004e7f
    19b4:	100005fc 	.word	0x100005fc

Disassembly of section .text.gpio_ISR:

000019b8 <gpio_ISR>:
	while(1);
}
void gpio_ISR (void) {
    19b8:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr gpio");
    19ba:	4905      	ldr	r1, [pc, #20]	; (19d0 <gpio_ISR+0x18>)
    19bc:	2002      	movs	r0, #2
    19be:	f001 fc01 	bl	31c4 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(48);
    19c2:	4b04      	ldr	r3, [pc, #16]	; (19d4 <gpio_ISR+0x1c>)
    19c4:	681a      	ldr	r2, [r3, #0]
    19c6:	b112      	cbz	r2, 19ce <gpio_ISR+0x16>
    19c8:	681b      	ldr	r3, [r3, #0]
    19ca:	2030      	movs	r0, #48	; 0x30
    19cc:	4798      	blx	r3
    19ce:	e7fe      	b.n	19ce <gpio_ISR+0x16>
    19d0:	00004e8a 	.word	0x00004e8a
    19d4:	100005fc 	.word	0x100005fc

Disassembly of section .text.pwm0_ISR:

000019d8 <pwm0_ISR>:
	while(1);
}
void pwm0_ISR (void) {
    19d8:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr pwm0");
    19da:	4905      	ldr	r1, [pc, #20]	; (19f0 <pwm0_ISR+0x18>)
    19dc:	2002      	movs	r0, #2
    19de:	f001 fbf1 	bl	31c4 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(49);
    19e2:	4b04      	ldr	r3, [pc, #16]	; (19f4 <pwm0_ISR+0x1c>)
    19e4:	681a      	ldr	r2, [r3, #0]
    19e6:	b112      	cbz	r2, 19ee <pwm0_ISR+0x16>
    19e8:	681b      	ldr	r3, [r3, #0]
    19ea:	2031      	movs	r0, #49	; 0x31
    19ec:	4798      	blx	r3
    19ee:	e7fe      	b.n	19ee <pwm0_ISR+0x16>
    19f0:	00004e96 	.word	0x00004e96
    19f4:	100005fc 	.word	0x100005fc

Disassembly of section .text.eeprom_ISR:

000019f8 <eeprom_ISR>:
	while(1);
}
void eeprom_ISR (void) {
    19f8:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr eeprom");
    19fa:	4905      	ldr	r1, [pc, #20]	; (1a10 <eeprom_ISR+0x18>)
    19fc:	2002      	movs	r0, #2
    19fe:	f001 fbe1 	bl	31c4 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(50);
    1a02:	4b04      	ldr	r3, [pc, #16]	; (1a14 <eeprom_ISR+0x1c>)
    1a04:	681a      	ldr	r2, [r3, #0]
    1a06:	b112      	cbz	r2, 1a0e <eeprom_ISR+0x16>
    1a08:	681b      	ldr	r3, [r3, #0]
    1a0a:	2032      	movs	r0, #50	; 0x32
    1a0c:	4798      	blx	r3
    1a0e:	e7fe      	b.n	1a0e <eeprom_ISR+0x16>
    1a10:	00004ea2 	.word	0x00004ea2
    1a14:	100005fc 	.word	0x100005fc

Disassembly of section .text.nvic_setPendingIRQ:

00001a18 <nvic_setPendingIRQ>:
// Parametro:	ID da interrupção do periférico
// Retorna:		Nada
// -----------------------------------------------------------------------------------------------
void nvic_setPendingIRQ(u8 numIRQ) {
	reg32 *addrPort = &ISER0; 		// Pegar o endereço do registrador do periférico
	addrPort+=(reg32)(numIRQ/VIC_SIZE); 	// Determinar em que registrador pertence ao periférico
    1a18:	0943      	lsrs	r3, r0, #5
    1a1a:	009b      	lsls	r3, r3, #2
    1a1c:	f103 4360 	add.w	r3, r3, #3758096384	; 0xe0000000
	*addrPort = (1 << (numIRQ%VIC_SIZE));	// Habilitar a pendencia interrupção do periférico
    1a20:	f000 001f 	and.w	r0, r0, #31
    1a24:	2201      	movs	r2, #1
// Parametro:	ID da interrupção do periférico
// Retorna:		Nada
// -----------------------------------------------------------------------------------------------
void nvic_setPendingIRQ(u8 numIRQ) {
	reg32 *addrPort = &ISER0; 		// Pegar o endereço do registrador do periférico
	addrPort+=(reg32)(numIRQ/VIC_SIZE); 	// Determinar em que registrador pertence ao periférico
    1a26:	f503 4361 	add.w	r3, r3, #57600	; 0xe100
	*addrPort = (1 << (numIRQ%VIC_SIZE));	// Habilitar a pendencia interrupção do periférico
    1a2a:	fa02 f000 	lsl.w	r0, r2, r0
    1a2e:	6018      	str	r0, [r3, #0]
    1a30:	4770      	bx	lr

Disassembly of section .text.nvic_enableIRQ:

00001a32 <nvic_enableIRQ>:
    1a32:	f7ff bff1 	b.w	1a18 <nvic_setPendingIRQ>

Disassembly of section .text.nvic_clearPendingIRQ:

00001a38 <nvic_clearPendingIRQ>:
// Parametro:	ID da interrupção do periférico
// Retorna:		Nada
// -----------------------------------------------------------------------------------------------
void nvic_clearPendingIRQ(u8 numIRQ) {
	reg32 *addrPort = &ICPR0; 		// Pegar o endereço do registrador do periférico
	addrPort+=(reg32)(numIRQ/VIC_SIZE); 	// Determinar em que registrador pertence ao periférico
    1a38:	0942      	lsrs	r2, r0, #5
	*addrPort = (1 << (numIRQ%VIC_SIZE));	// Desabilitar a pendencia interrupção do periférico
    1a3a:	2301      	movs	r3, #1
    1a3c:	f000 001f 	and.w	r0, r0, #31
    1a40:	fa03 f000 	lsl.w	r0, r3, r0
    1a44:	4b01      	ldr	r3, [pc, #4]	; (1a4c <nvic_clearPendingIRQ+0x14>)
    1a46:	f843 0022 	str.w	r0, [r3, r2, lsl #2]
    1a4a:	4770      	bx	lr
    1a4c:	e000e280 	.word	0xe000e280

Disassembly of section .text.nvic_setPriority:

00001a50 <nvic_setPriority>:
// -----------------------------------------------------------------------------------------------
void nvic_setPriority(s32 numIRQ, u8 priority) {
	#if (VIC_USE_DEBUG == pdON)
	plognp("set pri %d %u"CMD_TERMINATOR, numIRQ, priority);
	#endif
	if(numIRQ < 0) {
    1a50:	2800      	cmp	r0, #0
    1a52:	b2c3      	uxtb	r3, r0
    1a54:	ea4f 01c1 	mov.w	r1, r1, lsl #3
    1a58:	da0d      	bge.n	1a76 <nvic_setPriority+0x26>
		addrPort+=(reg32)(((numIRQ&0xf)-4)/4); 	// Determinar em que registrador pertence ao periférico.
												//   (numIRQ&0xf)-4 para converte o valor negativo
		// cada registrador de 32 bits, guarda a prioridade de 4 periféricos
		// logo cada byte é para cada periférico, então precisamo encontrar em que local [e
		reg8 *offset = (reg8*) addrPort;
		offset+=(reg8)((numIRQ&0xf)-4)%4;
    1a5a:	f000 000f 	and.w	r0, r0, #15
    1a5e:	2204      	movs	r2, #4
    1a60:	3804      	subs	r0, #4
    1a62:	fb90 f0f2 	sdiv	r0, r0, r2
    1a66:	f003 0303 	and.w	r3, r3, #3
		*offset = ((priority << (8 - VIC_PRIO_BITS)) & 0xff);
    1a6a:	4a09      	ldr	r2, [pc, #36]	; (1a90 <nvic_setPriority+0x40>)
		addrPort+=(reg32)(((numIRQ&0xf)-4)/4); 	// Determinar em que registrador pertence ao periférico.
												//   (numIRQ&0xf)-4 para converte o valor negativo
		// cada registrador de 32 bits, guarda a prioridade de 4 periféricos
		// logo cada byte é para cada periférico, então precisamo encontrar em que local [e
		reg8 *offset = (reg8*) addrPort;
		offset+=(reg8)((numIRQ&0xf)-4)%4;
    1a6c:	eb03 0380 	add.w	r3, r3, r0, lsl #2
		*offset = ((priority << (8 - VIC_PRIO_BITS)) & 0xff);
    1a70:	b2c9      	uxtb	r1, r1
    1a72:	5499      	strb	r1, [r3, r2]
    1a74:	4770      	bx	lr
		// logo cada byte é para cada periférico, então precisamo encontrar em que local [e
		reg8 *offset = (reg8*) addrPort;
		#if (VIC_USE_DEBUG == pdON)
		plognp("offset init 0x%x"CMD_TERMINATOR, offset);
		#endif
		offset+=(reg8)numIRQ%4;
    1a76:	f020 0003 	bic.w	r0, r0, #3
    1a7a:	f003 0303 	and.w	r3, r3, #3
    1a7e:	4418      	add	r0, r3
    1a80:	f100 4060 	add.w	r0, r0, #3758096384	; 0xe0000000
    1a84:	f500 4064 	add.w	r0, r0, #58368	; 0xe400
		#if (VIC_USE_DEBUG == pdON)
		plognp("offset 0x%x = 0x%x"CMD_TERMINATOR, offset, ((priority << (8 - VIC_PRIO_BITS)) & 0xff));
		#endif
		*offset = ((priority << (8 - VIC_PRIO_BITS)) & 0xff);
    1a88:	b2c9      	uxtb	r1, r1
    1a8a:	7001      	strb	r1, [r0, #0]
    1a8c:	4770      	bx	lr
    1a8e:	bf00      	nop
    1a90:	e000ed18 	.word	0xe000ed18

Disassembly of section .text.nvic_SetIntHandler:

00001a94 <nvic_SetIntHandler>:
//						}
//						ATENÇÃO: NUNCA USA O DELAY COM INTERRUPÇÃO, USE A LIB COM LOOP, pois se este é um procedimento de erro de
// Retorna:		Nada
// ----------------------------------------------------------------------------------------------------------------
void nvic_SetIntHandler(void (*func)(int) ) {
	vicerr_Functions = func;
    1a94:	4b01      	ldr	r3, [pc, #4]	; (1a9c <nvic_SetIntHandler+0x8>)
    1a96:	6018      	str	r0, [r3, #0]
    1a98:	4770      	bx	lr
    1a9a:	bf00      	nop
    1a9c:	100005fc 	.word	0x100005fc

Disassembly of section .text.systime_Init:

00001aa0 <systime_Init>:
// Parametros:	Nenhum
// Retorna:		Nada
// -------------------------------------------------------------------------------------------------------------------
int systime_Init(void) {
	#if (SYSTIME_USE_LED == pdON)
	ledSYSTIME_DIR |= ledSYSTIME; 					// Colocar o pino do led para saida
    1aa0:	4a10      	ldr	r2, [pc, #64]	; (1ae4 <systime_Init+0x44>)

  	systime_ClearIntHandler(); // retira qualquer função anexada para interrupção do systime
  	countTicks_ms = 0; // Limpa o contador de ticks do sistema

	return pdPASS;
}
    1aa2:	2001      	movs	r0, #1
// Parametros:	Nenhum
// Retorna:		Nada
// -------------------------------------------------------------------------------------------------------------------
int systime_Init(void) {
	#if (SYSTIME_USE_LED == pdON)
	ledSYSTIME_DIR |= ledSYSTIME; 					// Colocar o pino do led para saida
    1aa4:	6813      	ldr	r3, [r2, #0]
    1aa6:	f043 5380 	orr.w	r3, r3, #268435456	; 0x10000000
    1aaa:	6013      	str	r3, [r2, #0]
	countTicksLed = 0;
    1aac:	4b0e      	ldr	r3, [pc, #56]	; (1ae8 <systime_Init+0x48>)
    1aae:	2200      	movs	r2, #0
    1ab0:	601a      	str	r2, [r3, #0]
	#endif

	// Make PendSV and SysTick the lowest priority interrupts
	NVIC_SYSPRI2_REG |= ( ( ( u32 ) configINTERRUPT_PRIORITY ) << 16UL );
    1ab2:	4b0e      	ldr	r3, [pc, #56]	; (1aec <systime_Init+0x4c>)
    1ab4:	6819      	ldr	r1, [r3, #0]
	NVIC_SYSPRI2_REG |= ( ( ( u32 ) configINTERRUPT_PRIORITY ) << 24UL );

	// Configure SysTick to interrupt at the requested rate.
	STRELOAD = ( CCLK / 1000 / SYSTIME_BASE_TICK ) - 1UL;
    1ab6:	f6a3 530c 	subw	r3, r3, #3340	; 0xd0c
	ledSYSTIME_DIR |= ledSYSTIME; 					// Colocar o pino do led para saida
	countTicksLed = 0;
	#endif

	// Make PendSV and SysTick the lowest priority interrupts
	NVIC_SYSPRI2_REG |= ( ( ( u32 ) configINTERRUPT_PRIORITY ) << 16UL );
    1aba:	f441 0178 	orr.w	r1, r1, #16252928	; 0xf80000
    1abe:	f8c3 1d0c 	str.w	r1, [r3, #3340]	; 0xd0c
	NVIC_SYSPRI2_REG |= ( ( ( u32 ) configINTERRUPT_PRIORITY ) << 24UL );
    1ac2:	f8d3 1d0c 	ldr.w	r1, [r3, #3340]	; 0xd0c
    1ac6:	f041 4178 	orr.w	r1, r1, #4160749568	; 0xf8000000
    1aca:	f8c3 1d0c 	str.w	r1, [r3, #3340]	; 0xd0c

	// Configure SysTick to interrupt at the requested rate.
	STRELOAD = ( CCLK / 1000 / SYSTIME_BASE_TICK ) - 1UL;
    1ace:	4908      	ldr	r1, [pc, #32]	; (1af0 <systime_Init+0x50>)
    1ad0:	6019      	str	r1, [r3, #0]
	STCTRL = ( STCTRL_CLKSOURCE | STCTRL_TICKINT | STCTRL_ENABLE );
    1ad2:	2107      	movs	r1, #7
    1ad4:	f843 1c04 	str.w	r1, [r3, #-4]
// Descrição: 	Retira a routina da inetrrupçao desejada do vetor de interrupções
// Parametros:	Nenhum
// Retorna:		Nada
// ----------------------------------------------------------------------------------------------------------------
void systime_ClearIntHandler(void) {
	systime_IntFunctions = 0;
    1ad8:	4b06      	ldr	r3, [pc, #24]	; (1af4 <systime_Init+0x54>)
    1ada:	601a      	str	r2, [r3, #0]
	// Configure SysTick to interrupt at the requested rate.
	STRELOAD = ( CCLK / 1000 / SYSTIME_BASE_TICK ) - 1UL;
	STCTRL = ( STCTRL_CLKSOURCE | STCTRL_TICKINT | STCTRL_ENABLE );

  	systime_ClearIntHandler(); // retira qualquer função anexada para interrupção do systime
  	countTicks_ms = 0; // Limpa o contador de ticks do sistema
    1adc:	4b06      	ldr	r3, [pc, #24]	; (1af8 <systime_Init+0x58>)
    1ade:	601a      	str	r2, [r3, #0]

	return pdPASS;
}
    1ae0:	4770      	bx	lr
    1ae2:	bf00      	nop
    1ae4:	2009c080 	.word	0x2009c080
    1ae8:	10000600 	.word	0x10000600
    1aec:	e000ed20 	.word	0xe000ed20
    1af0:	0001869f 	.word	0x0001869f
    1af4:	1000060c 	.word	0x1000060c
    1af8:	10000604 	.word	0x10000604

Disassembly of section .text.systime_SetIntHandler:

00001afc <systime_SetIntHandler>:
//					Ponteiro da rotina que tratará a interrupção do timer.
//					Ex:	systime_SetIntHandler(myOverflowFunction, xticks);
//				xticks: Quantidade de ticks que a função deve ser chamada. Consultar SYSTIME_BASE_TICK
// Retorna:		Nada
// ----------------------------------------------------------------------------------------------------------------
void systime_SetIntHandler(void (*int_func)(void), uint xticks ) {
    1afc:	4b02      	ldr	r3, [pc, #8]	; (1b08 <systime_SetIntHandler+0xc>)
	if (xticks == 0) { systime_IntFunctions = 0; return;}
    1afe:	b109      	cbz	r1, 1b04 <systime_SetIntHandler+0x8>
	systime_IntFunctions = int_func;
    1b00:	6018      	str	r0, [r3, #0]
	callfuncTime = xticks;
    1b02:	4b02      	ldr	r3, [pc, #8]	; (1b0c <systime_SetIntHandler+0x10>)
    1b04:	6019      	str	r1, [r3, #0]
    1b06:	4770      	bx	lr
    1b08:	1000060c 	.word	0x1000060c
    1b0c:	10000608 	.word	0x10000608

Disassembly of section .text.sysTick_ISR:

00001b10 <sysTick_ISR>:

// ################################################################################################################
// SYSTEM TIMER INTERRUPÇÃO
// ################################################################################################################
// ################################################################################################################
void sysTick_ISR (void) {
    1b10:	b508      	push	{r3, lr}
    ISR_ENTRY;	// Procedimento para entrada da interrupção

	countTicks_ms++;
    1b12:	4b12      	ldr	r3, [pc, #72]	; (1b5c <sysTick_ISR+0x4c>)

	// Checa se existe uma função anexada a interrupção e é tempo de chamar a função
	if ( (systime_IntFunctions) && (countTicks_ms % callfuncTime == 0))
    1b14:	4912      	ldr	r1, [pc, #72]	; (1b60 <sysTick_ISR+0x50>)
// ################################################################################################################
// ################################################################################################################
void sysTick_ISR (void) {
    ISR_ENTRY;	// Procedimento para entrada da interrupção

	countTicks_ms++;
    1b16:	681a      	ldr	r2, [r3, #0]
    1b18:	3201      	adds	r2, #1
    1b1a:	601a      	str	r2, [r3, #0]

	// Checa se existe uma função anexada a interrupção e é tempo de chamar a função
	if ( (systime_IntFunctions) && (countTicks_ms % callfuncTime == 0))
    1b1c:	680a      	ldr	r2, [r1, #0]
    1b1e:	b14a      	cbz	r2, 1b34 <sysTick_ISR+0x24>
    1b20:	6818      	ldr	r0, [r3, #0]
    1b22:	4b10      	ldr	r3, [pc, #64]	; (1b64 <sysTick_ISR+0x54>)
    1b24:	681b      	ldr	r3, [r3, #0]
    1b26:	fbb0 f2f3 	udiv	r2, r0, r3
    1b2a:	fb03 0312 	mls	r3, r3, r2, r0
    1b2e:	b90b      	cbnz	r3, 1b34 <sysTick_ISR+0x24>
		systime_IntFunctions();					// Execute a função anexada
    1b30:	680b      	ldr	r3, [r1, #0]
    1b32:	4798      	blx	r3

	#if (SYSTIME_USE_LED == pdON)
	if (countTicksLed >= SYSTIME_LED_OFF_MS*SYSTIME_BASE_TICK + SYSTIME_LED_ON_MS*SYSTIME_BASE_TICK)
    1b34:	4b0c      	ldr	r3, [pc, #48]	; (1b68 <sysTick_ISR+0x58>)
    1b36:	681a      	ldr	r2, [r3, #0]
    1b38:	f5b2 7f7a 	cmp.w	r2, #1000	; 0x3e8
		countTicksLed = 0;
    1b3c:	bf24      	itt	cs
    1b3e:	2200      	movcs	r2, #0
    1b40:	601a      	strcs	r2, [r3, #0]
		countTicksLed++;
    1b42:	681a      	ldr	r2, [r3, #0]
    1b44:	3201      	adds	r2, #1
    1b46:	601a      	str	r2, [r3, #0]
		if (countTicksLed > SYSTIME_LED_OFF_MS*SYSTIME_BASE_TICK) {
    1b48:	681b      	ldr	r3, [r3, #0]
    1b4a:	f5b3 7f61 	cmp.w	r3, #900	; 0x384
			ledSYSTIME_ON = ledSYSTIME;
    1b4e:	bf8c      	ite	hi
    1b50:	4a06      	ldrhi	r2, [pc, #24]	; (1b6c <sysTick_ISR+0x5c>)
		} else {
			ledSYSTIME_OFF = ledSYSTIME;
    1b52:	4a07      	ldrls	r2, [pc, #28]	; (1b70 <sysTick_ISR+0x60>)
    1b54:	f04f 5380 	mov.w	r3, #268435456	; 0x10000000
    1b58:	6013      	str	r3, [r2, #0]
    1b5a:	bd08      	pop	{r3, pc}
    1b5c:	10000604 	.word	0x10000604
    1b60:	1000060c 	.word	0x1000060c
    1b64:	10000608 	.word	0x10000608
    1b68:	10000600 	.word	0x10000600
    1b6c:	2009c098 	.word	0x2009c098
    1b70:	2009c09c 	.word	0x2009c09c

Disassembly of section .text.delay:

00001b74 <delay>:
*/

#include "delay.h"

void delay(u32 delayval) {
	asm volatile (
    1b74:	3801      	subs	r0, #1
    1b76:	d1fd      	bne.n	1b74 <delay>
    1b78:	4770      	bx	lr

Disassembly of section .text.uart0_SetBaudrate:

00001b80 <uart0_SetBaudrate>:
		}
	}
	return r;
}

void uart0_SetBaudrate(u32 baudrate) {
    1b80:	e92d 4ff7 	stmdb	sp!, {r0, r1, r2, r4, r5, r6, r7, r8, r9, sl, fp, lr}
    1b84:	4680      	mov	r8, r0
  	U0LCR = U1LCR_DLAB_ENABLE;             						// Seleciona os latches de devisões para ajusta do baudrate
    1b86:	4e34      	ldr	r6, [pc, #208]	; (1c58 <uart0_SetBaudrate+0xd8>)
//indiferente da frequência e do baud
//	detremina o valor dos registradores "DLM/DLL"
//	aqui forçamos o baud a ficar mais veloz do que o valor
//	desejado para que o ajuste através do FDR seja mais preciso
static int uart_dlm(int baud) {
	return (int)(((PCLK / 16) / baud) * 0.8);
    1b88:	4834      	ldr	r0, [pc, #208]	; (1c5c <uart0_SetBaudrate+0xdc>)
	}
	return r;
}

void uart0_SetBaudrate(u32 baudrate) {
  	U0LCR = U1LCR_DLAB_ENABLE;             						// Seleciona os latches de devisões para ajusta do baudrate
    1b8a:	2380      	movs	r3, #128	; 0x80
    1b8c:	6033      	str	r3, [r6, #0]
//indiferente da frequência e do baud
//	detremina o valor dos registradores "DLM/DLL"
//	aqui forçamos o baud a ficar mais veloz do que o valor
//	desejado para que o ajuste através do FDR seja mais preciso
static int uart_dlm(int baud) {
	return (int)(((PCLK / 16) / baud) * 0.8);
    1b8e:	fb90 f0f8 	sdiv	r0, r0, r8
    1b92:	f7fe fd05 	bl	5a0 <__aeabi_i2d>
    1b96:	a32c      	add	r3, pc, #176	; (adr r3, 1c48 <uart0_SetBaudrate+0xc8>)
    1b98:	e9d3 2300 	ldrd	r2, r3, [r3]
    1b9c:	f7fe fd66 	bl	66c <__aeabi_dmul>
    1ba0:	f7fe fffe 	bl	ba0 <__aeabi_d2iz>
#include <stdlib.h>
static int uart_fdr(int baud) {
	int d, m, b, e, r;
	float f;
	r = 1<<4; //apenas o MULVAL por default
	e = baud;
    1ba4:	46c2      	mov	sl, r8
//indiferente da frequência e do baud
//	detremina o valor dos registradores "DLM/DLL"
//	aqui forçamos o baud a ficar mais veloz do que o valor
//	desejado para que o ajuste através do FDR seja mais preciso
static int uart_dlm(int baud) {
	return (int)(((PCLK / 16) / baud) * 0.8);
    1ba6:	4607      	mov	r7, r0

void uart0_SetBaudrate(u32 baudrate) {
  	U0LCR = U1LCR_DLAB_ENABLE;             						// Seleciona os latches de devisões para ajusta do baudrate
  	u32 f_div = uart_dlm(baudrate);

  	U0DLL = f_div%256;        								// Ajusta o baudrate byte baixo
    1ba8:	4b2d      	ldr	r3, [pc, #180]	; (1c60 <uart0_SetBaudrate+0xe0>)
    1baa:	b2c2      	uxtb	r2, r0
    1bac:	601a      	str	r2, [r3, #0]
  	U0DLM = f_div/256;    									// Ajusta o baudrate byte alto
    1bae:	0a02      	lsrs	r2, r0, #8
    1bb0:	605a      	str	r2, [r3, #4]
//	fraction = BAUD*(1+D/M)
#include <stdlib.h>
static int uart_fdr(int baud) {
	int d, m, b, e, r;
	float f;
	r = 1<<4; //apenas o MULVAL por default
    1bb2:	f04f 0910 	mov.w	r9, #16
	e = baud;
	for(m=1;m<=15;m++) {
    1bb6:	2401      	movs	r4, #1
			//agora o valor final corrigido
			b = (int)(PCLK/(b*f*16.0));
			//erro ficou menor?
			if (abs(baud-b)<e) {
				e = abs(baud-b);
				r = (m<<4) + d;
    1bb8:	ea4f 1b04 	mov.w	fp, r4, lsl #4
    1bbc:	2500      	movs	r5, #0
			//calcula o baud truncado
			b = uart_dlm(baud);
			//agora o valor final corrigido
			b = (int)(PCLK/(b*f*16.0));
			//erro ficou menor?
			if (abs(baud-b)<e) {
    1bbe:	4628      	mov	r0, r5
    1bc0:	f7ff f8d0 	bl	d64 <__aeabi_i2f>
    1bc4:	9001      	str	r0, [sp, #4]
    1bc6:	4620      	mov	r0, r4
    1bc8:	f7ff f8cc 	bl	d64 <__aeabi_i2f>
    1bcc:	9b01      	ldr	r3, [sp, #4]
    1bce:	4601      	mov	r1, r0
    1bd0:	4618      	mov	r0, r3
    1bd2:	f7ff f9cf 	bl	f74 <__aeabi_fdiv>
    1bd6:	f04f 517e 	mov.w	r1, #1065353216	; 0x3f800000
    1bda:	f7ff f80f 	bl	bfc <__addsf3>
    1bde:	9001      	str	r0, [sp, #4]
    1be0:	4638      	mov	r0, r7
    1be2:	f7ff f8bf 	bl	d64 <__aeabi_i2f>
    1be6:	9b01      	ldr	r3, [sp, #4]
    1be8:	4601      	mov	r1, r0
    1bea:	4618      	mov	r0, r3
    1bec:	f7ff f90e 	bl	e0c <__aeabi_fmul>
    1bf0:	f7fe fce8 	bl	5c4 <__aeabi_f2d>
    1bf4:	2200      	movs	r2, #0
    1bf6:	4b1b      	ldr	r3, [pc, #108]	; (1c64 <uart0_SetBaudrate+0xe4>)
    1bf8:	f7fe fd38 	bl	66c <__aeabi_dmul>
    1bfc:	4602      	mov	r2, r0
    1bfe:	460b      	mov	r3, r1
    1c00:	a113      	add	r1, pc, #76	; (adr r1, 1c50 <uart0_SetBaudrate+0xd0>)
    1c02:	e9d1 0100 	ldrd	r0, r1, [r1]
    1c06:	f7fe fe5b 	bl	8c0 <__aeabi_ddiv>
    1c0a:	f7fe ffc9 	bl	ba0 <__aeabi_d2iz>
    1c0e:	ebc0 0008 	rsb	r0, r0, r8
    1c12:	2800      	cmp	r0, #0
    1c14:	bfb8      	it	lt
    1c16:	4240      	neglt	r0, r0
    1c18:	4550      	cmp	r0, sl
    1c1a:	bfb8      	it	lt
    1c1c:	eb05 090b 	addlt.w	r9, r5, fp
	int d, m, b, e, r;
	float f;
	r = 1<<4; //apenas o MULVAL por default
	e = baud;
	for(m=1;m<=15;m++) {
		for (d=0;d<m;d++) {
    1c20:	f105 0501 	add.w	r5, r5, #1
			//calcula o baud truncado
			b = uart_dlm(baud);
			//agora o valor final corrigido
			b = (int)(PCLK/(b*f*16.0));
			//erro ficou menor?
			if (abs(baud-b)<e) {
    1c24:	bfb8      	it	lt
    1c26:	4682      	movlt	sl, r0
	int d, m, b, e, r;
	float f;
	r = 1<<4; //apenas o MULVAL por default
	e = baud;
	for(m=1;m<=15;m++) {
		for (d=0;d<m;d++) {
    1c28:	42ac      	cmp	r4, r5
    1c2a:	d1c8      	bne.n	1bbe <uart0_SetBaudrate+0x3e>
static int uart_fdr(int baud) {
	int d, m, b, e, r;
	float f;
	r = 1<<4; //apenas o MULVAL por default
	e = baud;
	for(m=1;m<=15;m++) {
    1c2c:	3401      	adds	r4, #1
    1c2e:	2c10      	cmp	r4, #16
    1c30:	d1c2      	bne.n	1bb8 <uart0_SetBaudrate+0x38>
  	U0LCR = U1LCR_DLAB_ENABLE;             						// Seleciona os latches de devisões para ajusta do baudrate
  	u32 f_div = uart_dlm(baudrate);

  	U0DLL = f_div%256;        								// Ajusta o baudrate byte baixo
  	U0DLM = f_div/256;    									// Ajusta o baudrate byte alto
  	U0FDR = uart_fdr(baudrate);
    1c32:	4b0d      	ldr	r3, [pc, #52]	; (1c68 <uart0_SetBaudrate+0xe8>)
    1c34:	f8c3 9000 	str.w	r9, [r3]
	U0LCR = (UART0_MODE & ~U0LCR_DLAB_ENABLE);					// Configura o modo de trabalho da uart e desativa o acesso aos registradores do baudrate
    1c38:	2303      	movs	r3, #3
    1c3a:	6033      	str	r3, [r6, #0]
}
    1c3c:	b003      	add	sp, #12
    1c3e:	e8bd 8ff0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
    1c42:	bf00      	nop
    1c44:	f3af 8000 	nop.w
    1c48:	9999999a 	.word	0x9999999a
    1c4c:	3fe99999 	.word	0x3fe99999
    1c50:	00000000 	.word	0x00000000
    1c54:	4177d784 	.word	0x4177d784
    1c58:	4000c00c 	.word	0x4000c00c
    1c5c:	0017d784 	.word	0x0017d784
    1c60:	4000c000 	.word	0x4000c000
    1c64:	40300000 	.word	0x40300000
    1c68:	4000c028 	.word	0x4000c028

Disassembly of section .text.uart0_Init:

00001c6c <uart0_Init>:
// Parametros:	baudrate: 
//					1200, 2400, ... , 57600, 115200 ...
// Retorna:		retorna pdPASS se iniciliazou sem problemas ou retorna código do erro
// -------------------------------------------------------------------------------------------------------------------
int uart0_Init(u32 baudrate) {
  	PCONP |= PCUART0;											// Ligar a uart no controle de potencia. Tem que ser antes da configuração, pois após ligar o periféricos, seus regs assumem valores padrões
    1c6c:	4a1d      	ldr	r2, [pc, #116]	; (1ce4 <uart0_Init+0x78>)
// Descrição: 	Incializa e configura o modo de trabalho da UART
// Parametros:	baudrate: 
//					1200, 2400, ... , 57600, 115200 ...
// Retorna:		retorna pdPASS se iniciliazou sem problemas ou retorna código do erro
// -------------------------------------------------------------------------------------------------------------------
int uart0_Init(u32 baudrate) {
    1c6e:	b5f8      	push	{r3, r4, r5, r6, r7, lr}
  	PCONP |= PCUART0;											// Ligar a uart no controle de potencia. Tem que ser antes da configuração, pois após ligar o periféricos, seus regs assumem valores padrões
    1c70:	6813      	ldr	r3, [r2, #0]
	U0_CTS_DIR &= ~U0_CTS; 				// Pino CTS como entrada
	U0_RTS_DIR |= U0_RTS; 				// Pino RTS como saída
	uart0_RTSon(); 						// Sinaliza que posso receber dados
  	#endif

  	U0IER = 0;   	                      						// Desabilita todas as fonte de interrupções da uart
    1c72:	4c1d      	ldr	r4, [pc, #116]	; (1ce8 <uart0_Init+0x7c>)
// Parametros:	baudrate: 
//					1200, 2400, ... , 57600, 115200 ...
// Retorna:		retorna pdPASS se iniciliazou sem problemas ou retorna código do erro
// -------------------------------------------------------------------------------------------------------------------
int uart0_Init(u32 baudrate) {
  	PCONP |= PCUART0;											// Ligar a uart no controle de potencia. Tem que ser antes da configuração, pois após ligar o periféricos, seus regs assumem valores padrões
    1c74:	f043 0308 	orr.w	r3, r3, #8
    1c78:	6013      	str	r3, [r2, #0]
	#if defined(arm7tdmi)
  	U0_PINSEL = (U0_PINSEL & ~U0_PINMASK) | U0_PINS;			// Configura os pinos do uC para a função UART. Pinos TX=P0_2 e RX=P0_3
	#endif //arm7tdmi

	#if defined(cortexm3)
  	uart0_ConfigPort();
    1c7a:	4a1c      	ldr	r2, [pc, #112]	; (1cec <uart0_Init+0x80>)
	U0_RTS_DIR |= U0_RTS; 				// Pino RTS como saída
	uart0_RTSon(); 						// Sinaliza que posso receber dados
  	#endif

  	U0IER = 0;   	                      						// Desabilita todas as fonte de interrupções da uart
  	U0IIR;                                						// Limpa os identificadores de pendencia interrupções da uart
    1c7c:	4d1c      	ldr	r5, [pc, #112]	; (1cf0 <uart0_Init+0x84>)
	#if defined(arm7tdmi)
  	U0_PINSEL = (U0_PINSEL & ~U0_PINMASK) | U0_PINS;			// Configura os pinos do uC para a função UART. Pinos TX=P0_2 e RX=P0_3
	#endif //arm7tdmi

	#if defined(cortexm3)
  	uart0_ConfigPort();
    1c7e:	6813      	ldr	r3, [r2, #0]
	U0_CTS_DIR &= ~U0_CTS; 				// Pino CTS como entrada
	U0_RTS_DIR |= U0_RTS; 				// Pino RTS como saída
	uart0_RTSon(); 						// Sinaliza que posso receber dados
  	#endif

  	U0IER = 0;   	                      						// Desabilita todas as fonte de interrupções da uart
    1c80:	2600      	movs	r6, #0
	#if defined(arm7tdmi)
  	U0_PINSEL = (U0_PINSEL & ~U0_PINMASK) | U0_PINS;			// Configura os pinos do uC para a função UART. Pinos TX=P0_2 e RX=P0_3
	#endif //arm7tdmi

	#if defined(cortexm3)
  	uart0_ConfigPort();
    1c82:	f043 0350 	orr.w	r3, r3, #80	; 0x50
    1c86:	6013      	str	r3, [r2, #0]
	U0_CTS_DIR &= ~U0_CTS; 				// Pino CTS como entrada
	U0_RTS_DIR |= U0_RTS; 				// Pino RTS como saída
	uart0_RTSon(); 						// Sinaliza que posso receber dados
  	#endif

  	U0IER = 0;   	                      						// Desabilita todas as fonte de interrupções da uart
    1c88:	6026      	str	r6, [r4, #0]
  	U0IIR;                                						// Limpa os identificadores de pendencia interrupções da uart
    1c8a:	682b      	ldr	r3, [r5, #0]
	U0FCR = (U0FCR_TX_FIFO_RESET | U0FCR_RX_FIFO_RESET);		// Limpa TX e RX FIFOS
    1c8c:	2306      	movs	r3, #6
    1c8e:	602b      	str	r3, [r5, #0]
  	
  	uart0_SetBaudrate(baudrate);
    1c90:	f7ff ff76 	bl	1b80 <uart0_SetBaudrate>

  	U0FCR = UART0_FIFOMODE;										// Configura o modo de trabalho da FIFO
    1c94:	2701      	movs	r7, #1
  	
  	U0RBR;                                						// Limpa o registrador de recepçao de dados
    1c96:	4b17      	ldr	r3, [pc, #92]	; (1cf4 <uart0_Init+0x88>)
  	U0IIR;                                						// Limpa os identificadores de pendencia interrupções da uart
	U0FCR = (U0FCR_TX_FIFO_RESET | U0FCR_RX_FIFO_RESET);		// Limpa TX e RX FIFOS
  	
  	uart0_SetBaudrate(baudrate);

  	U0FCR = UART0_FIFOMODE;										// Configura o modo de trabalho da FIFO
    1c98:	602f      	str	r7, [r5, #0]
  	
  	U0RBR;                                						// Limpa o registrador de recepçao de dados
    1c9a:	681b      	ldr	r3, [r3, #0]
  	U0LSR;                                						// Limpa o registrador de estado de linha
    1c9c:	4b16      	ldr	r3, [pc, #88]	; (1cf8 <uart0_Init+0x8c>)
  	if (!irq_Install(VIC_UART0, uart0_ISR, UART0_PRIO_LEVEL))
		return errIRQ_INSTALL;
	#endif

	#if defined (cortexm3)
	nvic_enableIRQ(VIC_UART0);
    1c9e:	2005      	movs	r0, #5
  	uart0_SetBaudrate(baudrate);

  	U0FCR = UART0_FIFOMODE;										// Configura o modo de trabalho da FIFO
  	
  	U0RBR;                                						// Limpa o registrador de recepçao de dados
  	U0LSR;                                						// Limpa o registrador de estado de linha
    1ca0:	681b      	ldr	r3, [r3, #0]
	U0FCR = U0FCR_RX_FIFO_RESET;								// Limpa a FIFO de recepção
    1ca2:	2302      	movs	r3, #2
    1ca4:	602b      	str	r3, [r5, #0]
  	U0FCR = U0FCR_TX_FIFO_RESET;          						// Limpa a FIFO de transmissão
    1ca6:	2304      	movs	r3, #4
    1ca8:	602b      	str	r3, [r5, #0]
  	if (!irq_Install(VIC_UART0, uart0_ISR, UART0_PRIO_LEVEL))
		return errIRQ_INSTALL;
	#endif

	#if defined (cortexm3)
	nvic_enableIRQ(VIC_UART0);
    1caa:	f7ff fec2 	bl	1a32 <nvic_enableIRQ>
	nvic_setPriority(VIC_UART0, UART0_PRIO_LEVEL);
    1cae:	2103      	movs	r1, #3
    1cb0:	2005      	movs	r0, #5
    1cb2:	f7ff fecd 	bl	1a50 <nvic_setPriority>
	#if (USE_MALLOC == pdON)
	u0_data_rx = malloc(UART0_RX_BUFFER_SIZE*sizeof(u8));
	u0_data_tx = malloc(UART0_TX_BUFFER_SIZE*sizeof(u8));
	#endif

	buffer_Init(&u0_buf_rx, u0_data_rx, UART0_RX_BUFFER_SIZE);
    1cb6:	2296      	movs	r2, #150	; 0x96
    1cb8:	4910      	ldr	r1, [pc, #64]	; (1cfc <uart0_Init+0x90>)
    1cba:	4811      	ldr	r0, [pc, #68]	; (1d00 <uart0_Init+0x94>)
    1cbc:	f001 fa97 	bl	31ee <buffer_Init>
	buffer_Init(&u0_buf_tx, u0_data_tx, UART0_TX_BUFFER_SIZE);
    1cc0:	2296      	movs	r2, #150	; 0x96
    1cc2:	4910      	ldr	r1, [pc, #64]	; (1d04 <uart0_Init+0x98>)
    1cc4:	4810      	ldr	r0, [pc, #64]	; (1d08 <uart0_Init+0x9c>)
    1cc6:	f001 fa92 	bl	31ee <buffer_Init>
		
	u0_overflow_rx = 0; 										// Limpa overflow do buffer de recepção
    1cca:	4b10      	ldr	r3, [pc, #64]	; (1d0c <uart0_Init+0xa0>)
	
	U0IER |= U0IER_ERBFI;										// Habilita interrupção de dados prontos na recepção e CTI (SIMULADOR PROTEUS NÃO FUNCIONA CTI)
	U0IER &= ~U0IER_ETBEI;                						// Desabilita a interrupção de buffer vazio de transmissão

	return pdPASS;
}
    1ccc:	4638      	mov	r0, r7
	#endif

	buffer_Init(&u0_buf_rx, u0_data_rx, UART0_RX_BUFFER_SIZE);
	buffer_Init(&u0_buf_tx, u0_data_tx, UART0_TX_BUFFER_SIZE);
		
	u0_overflow_rx = 0; 										// Limpa overflow do buffer de recepção
    1cce:	801e      	strh	r6, [r3, #0]
	u0_tx_running = pdFALSE;
    1cd0:	4b0f      	ldr	r3, [pc, #60]	; (1d10 <uart0_Init+0xa4>)
    1cd2:	701e      	strb	r6, [r3, #0]
	
	U0IER |= U0IER_ERBFI;										// Habilita interrupção de dados prontos na recepção e CTI (SIMULADOR PROTEUS NÃO FUNCIONA CTI)
    1cd4:	6823      	ldr	r3, [r4, #0]
    1cd6:	433b      	orrs	r3, r7
    1cd8:	6023      	str	r3, [r4, #0]
	U0IER &= ~U0IER_ETBEI;                						// Desabilita a interrupção de buffer vazio de transmissão
    1cda:	6823      	ldr	r3, [r4, #0]
    1cdc:	f023 0302 	bic.w	r3, r3, #2
    1ce0:	6023      	str	r3, [r4, #0]

	return pdPASS;
}
    1ce2:	bdf8      	pop	{r3, r4, r5, r6, r7, pc}
    1ce4:	400fc0c4 	.word	0x400fc0c4
    1ce8:	4000c004 	.word	0x4000c004
    1cec:	4002c000 	.word	0x4002c000
    1cf0:	4000c008 	.word	0x4000c008
    1cf4:	4000c000 	.word	0x4000c000
    1cf8:	4000c014 	.word	0x4000c014
    1cfc:	100006c4 	.word	0x100006c4
    1d00:	100006ac 	.word	0x100006ac
    1d04:	10000610 	.word	0x10000610
    1d08:	100006b8 	.word	0x100006b8
    1d0c:	100006a8 	.word	0x100006a8
    1d10:	100006a6 	.word	0x100006a6

Disassembly of section .text.uart0_GetChar:

00001d14 <uart0_GetChar>:
// -------------------------------------------------------------------------------------------------------------------
// Descrição:	Captura o próximo byte recebido na UART
// Parametros: 	Ponteiro para da variavel char para o retorno do byte recebido
// Retorna:		pdPASS indicando que existe caractere recebido ou o código do erro
// -------------------------------------------------------------------------------------------------------------------
int uart0_GetChar(u8 *ch) {
    1d14:	b538      	push	{r3, r4, r5, lr}
    1d16:	4605      	mov	r5, r0
	int ret;

	if ( u0_buf_rx.size == 0 )								// Checa se o buffer de recepção ainda não foi criado
    1d18:	480d      	ldr	r0, [pc, #52]	; (1d50 <uart0_GetChar+0x3c>)
    1d1a:	8883      	ldrh	r3, [r0, #4]
    1d1c:	b29b      	uxth	r3, r3
    1d1e:	b18b      	cbz	r3, 1d44 <uart0_GetChar+0x30>
   		return errBUFFER_NO_EXIST;            				// Retorna indicando erro

	if ( u0_buf_rx.datalength ) {							// Checo de o buffer de recepção contêm dados recebidos pela UART
    1d20:	88c3      	ldrh	r3, [r0, #6]
    1d22:	b29b      	uxth	r3, r3
    1d24:	b18b      	cbz	r3, 1d4a <uart0_GetChar+0x36>
		U0IER &= ~U0IER_ERBFI;								// Desabilita interrupção de dados prontos na recepção e CTI (SIMULADOR PROTEUS NÃO FUNCIONA CTI)
    1d26:	4c0b      	ldr	r4, [pc, #44]	; (1d54 <uart0_GetChar+0x40>)
    1d28:	6823      	ldr	r3, [r4, #0]
    1d2a:	f023 0301 	bic.w	r3, r3, #1
    1d2e:	6023      	str	r3, [r4, #0]
		nop();
    1d30:	bf00      	nop
		*ch = buffer_GetFromFront(&u0_buf_rx);				// Captura os dados do inicio do buffer
    1d32:	f001 fa62 	bl	31fa <buffer_GetFromFront>
    1d36:	7028      	strb	r0, [r5, #0]
		U0IER |= U0IER_ERBFI;								// Habilita interrupção de dados prontos na recepção e CTI (SIMULADOR PROTEUS NÃO FUNCIONA CTI)
    1d38:	6823      	ldr	r3, [r4, #0]
		ret = pdPASS;
    1d3a:	2001      	movs	r0, #1

	if ( u0_buf_rx.datalength ) {							// Checo de o buffer de recepção contêm dados recebidos pela UART
		U0IER &= ~U0IER_ERBFI;								// Desabilita interrupção de dados prontos na recepção e CTI (SIMULADOR PROTEUS NÃO FUNCIONA CTI)
		nop();
		*ch = buffer_GetFromFront(&u0_buf_rx);				// Captura os dados do inicio do buffer
		U0IER |= U0IER_ERBFI;								// Habilita interrupção de dados prontos na recepção e CTI (SIMULADOR PROTEUS NÃO FUNCIONA CTI)
    1d3c:	f043 0301 	orr.w	r3, r3, #1
    1d40:	6023      	str	r3, [r4, #0]
    1d42:	bd38      	pop	{r3, r4, r5, pc}
// -------------------------------------------------------------------------------------------------------------------
int uart0_GetChar(u8 *ch) {
	int ret;

	if ( u0_buf_rx.size == 0 )								// Checa se o buffer de recepção ainda não foi criado
   		return errBUFFER_NO_EXIST;            				// Retorna indicando erro
    1d44:	f06f 000b 	mvn.w	r0, #11
    1d48:	bd38      	pop	{r3, r4, r5, pc}
		nop();
		*ch = buffer_GetFromFront(&u0_buf_rx);				// Captura os dados do inicio do buffer
		U0IER |= U0IER_ERBFI;								// Habilita interrupção de dados prontos na recepção e CTI (SIMULADOR PROTEUS NÃO FUNCIONA CTI)
		ret = pdPASS;
	} else
		ret = errBUFFER_EMPTY;
    1d4a:	f06f 000a 	mvn.w	r0, #10

	return ret;
}
    1d4e:	bd38      	pop	{r3, r4, r5, pc}
    1d50:	100006ac 	.word	0x100006ac
    1d54:	4000c004 	.word	0x4000c004

Disassembly of section .text.uart0_PutChar:

00001d58 <uart0_PutChar>:
// Retorna:		Retorna pdPASS ou o código de erro
// -------------------------------------------------------------------------------------------------------------------
int uart0_PutChar(n16 ch) {
	int sts;

	if ( u0_buf_tx.size == 0 )												// Checa se o buffer de transmissão ainda não foi criado
    1d58:	4b15      	ldr	r3, [pc, #84]	; (1db0 <uart0_PutChar+0x58>)
// -------------------------------------------------------------------------------------------------------------------
// Descrição:	Coloca um caractere na fila de transmissão
// Parametros: 	Caractere a ser transmitindo
// Retorna:		Retorna pdPASS ou o código de erro
// -------------------------------------------------------------------------------------------------------------------
int uart0_PutChar(n16 ch) {
    1d5a:	b570      	push	{r4, r5, r6, lr}
	int sts;

	if ( u0_buf_tx.size == 0 )												// Checa se o buffer de transmissão ainda não foi criado
    1d5c:	889b      	ldrh	r3, [r3, #4]
    1d5e:	b29b      	uxth	r3, r3
    1d60:	b303      	cbz	r3, 1da4 <uart0_PutChar+0x4c>
	// É obrigatório incluirmos o char no buffer, mesmo que vamos retirá-lo logo em seguida caso u3_tx_running for FALSE
	//	Se não for dessa forma o e usar U3THR = ch haverá erro de sincronismo entre os dados chegas e dados enviados.
	// Isto porque o manipulador de interrupção (uart3_ISR) pode atender a mais de uma interrupção simulataneas

	do {
		U0IER &= ~U0IER_ETBEI;                 								// Desabilita a interrupção de transmissão
    1d62:	4c14      	ldr	r4, [pc, #80]	; (1db4 <uart0_PutChar+0x5c>)
		nop();
		sts = buffer_AddToEnd(&u0_buf_tx, ch);
    1d64:	b2c5      	uxtb	r5, r0
	// É obrigatório incluirmos o char no buffer, mesmo que vamos retirá-lo logo em seguida caso u3_tx_running for FALSE
	//	Se não for dessa forma o e usar U3THR = ch haverá erro de sincronismo entre os dados chegas e dados enviados.
	// Isto porque o manipulador de interrupção (uart3_ISR) pode atender a mais de uma interrupção simulataneas

	do {
		U0IER &= ~U0IER_ETBEI;                 								// Desabilita a interrupção de transmissão
    1d66:	6823      	ldr	r3, [r4, #0]
    1d68:	4e12      	ldr	r6, [pc, #72]	; (1db4 <uart0_PutChar+0x5c>)
    1d6a:	f023 0302 	bic.w	r3, r3, #2
    1d6e:	6023      	str	r3, [r4, #0]
		nop();
    1d70:	bf00      	nop
		sts = buffer_AddToEnd(&u0_buf_tx, ch);
    1d72:	480f      	ldr	r0, [pc, #60]	; (1db0 <uart0_PutChar+0x58>)
    1d74:	4629      	mov	r1, r5
    1d76:	f001 fa62 	bl	323e <buffer_AddToEnd>
		U0IER |= U0IER_ETBEI;                  								// Habilita a interrupção de transmissão
    1d7a:	6823      	ldr	r3, [r4, #0]

		CRITICAL_WAIT;														// Caso exista algum OS, pode trocar de contexto
	} while (sts == errBUFFER_FULL);
    1d7c:	300a      	adds	r0, #10

	do {
		U0IER &= ~U0IER_ETBEI;                 								// Desabilita a interrupção de transmissão
		nop();
		sts = buffer_AddToEnd(&u0_buf_tx, ch);
		U0IER |= U0IER_ETBEI;                  								// Habilita a interrupção de transmissão
    1d7e:	f043 0302 	orr.w	r3, r3, #2
    1d82:	6023      	str	r3, [r4, #0]

		CRITICAL_WAIT;														// Caso exista algum OS, pode trocar de contexto
	} while (sts == errBUFFER_FULL);
    1d84:	d0ef      	beq.n	1d66 <uart0_PutChar+0xe>

	if (!u0_tx_running) {													// Checa se existe dado sendo transmitido
    1d86:	4c0c      	ldr	r4, [pc, #48]	; (1db8 <uart0_PutChar+0x60>)
    1d88:	7823      	ldrb	r3, [r4, #0]
    1d8a:	b973      	cbnz	r3, 1daa <uart0_PutChar+0x52>
  		U0THR = buffer_GetFromFront(&u0_buf_tx);							// Atribui o dado do buffer ao registrador de transmissão
    1d8c:	4808      	ldr	r0, [pc, #32]	; (1db0 <uart0_PutChar+0x58>)
    1d8e:	f001 fa34 	bl	31fa <buffer_GetFromFront>
    1d92:	4b0a      	ldr	r3, [pc, #40]	; (1dbc <uart0_PutChar+0x64>)
    1d94:	6018      	str	r0, [r3, #0]
  		u0_tx_running = pdTRUE;												// Sinaliza que existe dado sendo trasnmitido
    1d96:	2001      	movs	r0, #1
    1d98:	7020      	strb	r0, [r4, #0]
  		U0IER |= U0IER_ETBEI;                  								// Habilita a interrupção de transmissão
    1d9a:	6833      	ldr	r3, [r6, #0]
    1d9c:	f043 0302 	orr.w	r3, r3, #2
    1da0:	6033      	str	r3, [r6, #0]
    1da2:	bd70      	pop	{r4, r5, r6, pc}
// -------------------------------------------------------------------------------------------------------------------
int uart0_PutChar(n16 ch) {
	int sts;

	if ( u0_buf_tx.size == 0 )												// Checa se o buffer de transmissão ainda não foi criado
   		return errBUFFER_NO_EXIST;                          				// Retorna indicando erro
    1da4:	f06f 000b 	mvn.w	r0, #11
    1da8:	bd70      	pop	{r4, r5, r6, pc}
  		U0THR = buffer_GetFromFront(&u0_buf_tx);							// Atribui o dado do buffer ao registrador de transmissão
  		u0_tx_running = pdTRUE;												// Sinaliza que existe dado sendo trasnmitido
  		U0IER |= U0IER_ETBEI;                  								// Habilita a interrupção de transmissão
   	}

  	return pdPASS;
    1daa:	2001      	movs	r0, #1
}
    1dac:	bd70      	pop	{r4, r5, r6, pc}
    1dae:	bf00      	nop
    1db0:	100006b8 	.word	0x100006b8
    1db4:	4000c004 	.word	0x4000c004
    1db8:	100006a6 	.word	0x100006a6
    1dbc:	4000c000 	.word	0x4000c000

Disassembly of section .text.uart0_BasicPutChar:

00001dc0 <uart0_BasicPutChar>:
// Descrição:	Coloca um caractere na fila de transmissão. FUNÇÃO UTIL PARA DEBUG ONDE NÃO PRECISA INICIAR IRQ ou OS
// Parametros: 	Caractere a ser transmitindo
// Retorna:		Retorna pdPASS ou o código de erro
// -------------------------------------------------------------------------------------------------------------------
int uart0_BasicPutChar(n16 ch) {
  	while (!(U0LSR & U0LSR_THRE))								// Espero até que o buffer TX fique vazio
    1dc0:	4a04      	ldr	r2, [pc, #16]	; (1dd4 <uart0_BasicPutChar+0x14>)
    1dc2:	6813      	ldr	r3, [r2, #0]
    1dc4:	069b      	lsls	r3, r3, #26
    1dc6:	d5fc      	bpl.n	1dc2 <uart0_BasicPutChar+0x2>
  		CRITICAL_WAIT;        									// Caso exista algum OS, pode trocar de contexto
  	U0THR = (u8)ch;												// Atualiza o registrador de TX uart com o dado
    1dc8:	4b03      	ldr	r3, [pc, #12]	; (1dd8 <uart0_BasicPutChar+0x18>)
    1dca:	b2c0      	uxtb	r0, r0
    1dcc:	6018      	str	r0, [r3, #0]
	return pdPASS;
}
    1dce:	2001      	movs	r0, #1
    1dd0:	4770      	bx	lr
    1dd2:	bf00      	nop
    1dd4:	4000c014 	.word	0x4000c014
    1dd8:	4000c000 	.word	0x4000c000

Disassembly of section .text.uart0_ISR:

00001ddc <uart0_ISR>:
//###################################################################################################################
// UART SERVIÇO DE INTERRUPÇÕES
// 		Descrição: 	Esta função implementa o ISR da UART0
//###################################################################################################################
//###################################################################################################################
void uart0_ISR (void) {
    1ddc:	e92d 41f0 	stmdb	sp!, {r4, r5, r6, r7, r8, lr}
	ISR_ENTRY;																// Procedimento para entrada da interrupção

  	u8 int_flags;
 	 	
  	while ( !((int_flags = U0IIR) & U0IIR_NO_INT) ) {							// Faça para todos os pedidos de interrupção pendentes emitidos pela UART 	
    1de0:	4e23      	ldr	r6, [pc, #140]	; (1e70 <uart0_ISR+0x94>)
    1de2:	4c24      	ldr	r4, [pc, #144]	; (1e74 <uart0_ISR+0x98>)
			// O registrador UxTHR é o topo da FIFO de 16 bytes, ou seja, é o endereço da última posição a ser inserida da FIFO
      	case U0IIR_THRE_INT:               									// Interrupção da FIFO de 16 bytes quando está vazia
        	while (U0LSR & U0LSR_THRE) {									// Faça enquanto há espaço na FIFO
        		if (buffer_IsEmpty(&u0_buf_tx) ) {							// Checa se o buffer de transmissão já está vazio
        			u0_tx_running = pdFALSE;     							// Sinaliza que não existe dados para trasnmissao
        			U0IER &= ~U0IER_ETBEI;                					// Desativa a interrupção de transmissão
    1de4:	4d24      	ldr	r5, [pc, #144]	; (1e78 <uart0_ISR+0x9c>)
void uart0_ISR (void) {
	ISR_ENTRY;																// Procedimento para entrada da interrupção

  	u8 int_flags;
 	 	
  	while ( !((int_flags = U0IIR) & U0IIR_NO_INT) ) {							// Faça para todos os pedidos de interrupção pendentes emitidos pela UART 	
    1de6:	6833      	ldr	r3, [r6, #0]
    1de8:	b2db      	uxtb	r3, r3
    1dea:	07da      	lsls	r2, r3, #31
    1dec:	d43a      	bmi.n	1e64 <uart0_ISR+0x88>
    	switch (int_flags & U0IIR_ID_MASK) {									// Identifica a fonte de interrupção
    1dee:	f003 030e 	and.w	r3, r3, #14
    1df2:	3b02      	subs	r3, #2
    1df4:	2b0a      	cmp	r3, #10
    1df6:	d831      	bhi.n	1e5c <uart0_ISR+0x80>
    1df8:	e8df f003 	tbb	[pc, r3]
    1dfc:	3008301b 	.word	0x3008301b
    1e00:	30303006 	.word	0x30303006
    1e04:	3030      	.short	0x3030
    1e06:	08          	.byte	0x08
    1e07:	00          	.byte	0x00
      	case U0IIR_RLS_INT:                									// Caso recebeu uma INT de erro na linha de recepção (receive line status)
        	U0LSR;                          								// Limpa registrador de status de linha
    1e08:	6823      	ldr	r3, [r4, #0]
        	break;
    1e0a:	e7ec      	b.n	1de6 <uart0_ISR+0xa>
        	// não alcançar o nível do trigger os dados da FIFO serão adicionados
        	// ao buffer de recepção pela interrupção de timerout da UART (U3IIR_CTI_INT)
      	case U0IIR_CTI_INT:                									// Character Timeout Indicator. Dados na FIFO RX que não foram lidos e está abaixo do nível de gatilho de int
      	case U0IIR_RDA_INT:                									// Caso que exista bytes disponivel recepção
      		do { 
      			if (buffer_AddToEnd(&u0_buf_rx, U0RBR) == errBUFFER_FULL)
    1e0c:	f8df 8074 	ldr.w	r8, [pc, #116]	; 1e84 <uart0_ISR+0xa8>
					u0_overflow_rx++;
    1e10:	4f1a      	ldr	r7, [pc, #104]	; (1e7c <uart0_ISR+0xa0>)
        	// não alcançar o nível do trigger os dados da FIFO serão adicionados
        	// ao buffer de recepção pela interrupção de timerout da UART (U3IIR_CTI_INT)
      	case U0IIR_CTI_INT:                									// Character Timeout Indicator. Dados na FIFO RX que não foram lidos e está abaixo do nível de gatilho de int
      	case U0IIR_RDA_INT:                									// Caso que exista bytes disponivel recepção
      		do { 
      			if (buffer_AddToEnd(&u0_buf_rx, U0RBR) == errBUFFER_FULL)
    1e12:	f8d8 1000 	ldr.w	r1, [r8]
    1e16:	481a      	ldr	r0, [pc, #104]	; (1e80 <uart0_ISR+0xa4>)
    1e18:	b2c9      	uxtb	r1, r1
    1e1a:	f001 fa10 	bl	323e <buffer_AddToEnd>
    1e1e:	300a      	adds	r0, #10
					u0_overflow_rx++;
    1e20:	bf01      	itttt	eq
    1e22:	883b      	ldrheq	r3, [r7, #0]
    1e24:	3301      	addeq	r3, #1
    1e26:	b29b      	uxtheq	r3, r3
    1e28:	803b      	strheq	r3, [r7, #0]
      		} while(U0LSR & U0LSR_RDR);										// Faça enquanto existe dados validos na FIFO de recepção
    1e2a:	6823      	ldr	r3, [r4, #0]
    1e2c:	07d8      	lsls	r0, r3, #31
    1e2e:	d4f0      	bmi.n	1e12 <uart0_ISR+0x36>
    1e30:	e7d9      	b.n	1de6 <uart0_ISR+0xa>
            		break;
          		} else {
					#if (UART0_USE_HANDSHAKING == pdON) // AINDA NÃO TESTADO
	    			if (uart0_CTS()) // Checa se o receptor esteja pronto para eviar dados
					#endif
	          			U0THR = buffer_GetFromFront(&u0_buf_tx);			// Atribui o dado do buffer ao registrador de transmissão
    1e32:	4f14      	ldr	r7, [pc, #80]	; (1e84 <uart0_ISR+0xa8>)

     	// RETIRA OS DADOS DO BUFFER TX PARA A FIFO DE TRANSMISSÃO
     		// Essa interrupção é gerada quando a FIFO de transmissão de 16 bytes está vazia
			// O registrador UxTHR é o topo da FIFO de 16 bytes, ou seja, é o endereço da última posição a ser inserida da FIFO
      	case U0IIR_THRE_INT:               									// Interrupção da FIFO de 16 bytes quando está vazia
        	while (U0LSR & U0LSR_THRE) {									// Faça enquanto há espaço na FIFO
    1e34:	6823      	ldr	r3, [r4, #0]
    1e36:	0699      	lsls	r1, r3, #26
    1e38:	d5d5      	bpl.n	1de6 <uart0_ISR+0xa>
        		if (buffer_IsEmpty(&u0_buf_tx) ) {							// Checa se o buffer de transmissão já está vazio
    1e3a:	4813      	ldr	r0, [pc, #76]	; (1e88 <uart0_ISR+0xac>)
    1e3c:	f001 fa1c 	bl	3278 <buffer_IsEmpty>
    1e40:	b138      	cbz	r0, 1e52 <uart0_ISR+0x76>
        			u0_tx_running = pdFALSE;     							// Sinaliza que não existe dados para trasnmissao
    1e42:	4b12      	ldr	r3, [pc, #72]	; (1e8c <uart0_ISR+0xb0>)
    1e44:	2200      	movs	r2, #0
    1e46:	701a      	strb	r2, [r3, #0]
        			U0IER &= ~U0IER_ETBEI;                					// Desativa a interrupção de transmissão
    1e48:	682b      	ldr	r3, [r5, #0]
    1e4a:	f023 0302 	bic.w	r3, r3, #2
    1e4e:	602b      	str	r3, [r5, #0]
            		break;
    1e50:	e7c9      	b.n	1de6 <uart0_ISR+0xa>
          		} else {
					#if (UART0_USE_HANDSHAKING == pdON) // AINDA NÃO TESTADO
	    			if (uart0_CTS()) // Checa se o receptor esteja pronto para eviar dados
					#endif
	          			U0THR = buffer_GetFromFront(&u0_buf_tx);			// Atribui o dado do buffer ao registrador de transmissão
    1e52:	480d      	ldr	r0, [pc, #52]	; (1e88 <uart0_ISR+0xac>)
    1e54:	f001 f9d1 	bl	31fa <buffer_GetFromFront>
    1e58:	6038      	str	r0, [r7, #0]
    1e5a:	e7eb      	b.n	1e34 <uart0_ISR+0x58>
          	}
		    
		    break;

      	default:															// Interrupção desconhecida
        	U0LSR;															// Limpa registrador de status de linha
    1e5c:	6823      	ldr	r3, [r4, #0]
        	U0RBR;															// Limpa o registrador de recepçao de dados
    1e5e:	4b09      	ldr	r3, [pc, #36]	; (1e84 <uart0_ISR+0xa8>)
    1e60:	681b      	ldr	r3, [r3, #0]
	       	break;
    1e62:	e7c0      	b.n	1de6 <uart0_ISR+0xa>
	// Limpa interrupção
  	#if defined(arm7tdmi)
  	VICSoftIntClr = (1<<VIC_UART0);
	#endif
	#if defined (cortexm3)
	nvic_clearPendingIRQ(VIC_UART0);
    1e64:	2005      	movs	r0, #5
	#endif

  	ISR_EXIT;																// Procedimento para saida da interrupção
}
    1e66:	e8bd 41f0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, lr}
	// Limpa interrupção
  	#if defined(arm7tdmi)
  	VICSoftIntClr = (1<<VIC_UART0);
	#endif
	#if defined (cortexm3)
	nvic_clearPendingIRQ(VIC_UART0);
    1e6a:	f7ff bde5 	b.w	1a38 <nvic_clearPendingIRQ>
    1e6e:	bf00      	nop
    1e70:	4000c008 	.word	0x4000c008
    1e74:	4000c014 	.word	0x4000c014
    1e78:	4000c004 	.word	0x4000c004
    1e7c:	100006a8 	.word	0x100006a8
    1e80:	100006ac 	.word	0x100006ac
    1e84:	4000c000 	.word	0x4000c000
    1e88:	100006b8 	.word	0x100006b8
    1e8c:	100006a6 	.word	0x100006a6

Disassembly of section .text.ssp1_SetClockFreq:

00001e90 <ssp1_SetClockFreq>:
// parametros	frequency: velocidade do barramento e HZ
//					cortexm3 max 10Mhz, para os demais 400KHz
// Retorna: 	A frequencia ajustada no barramento
//------------------------------------------------------------------------------------------------------------------
u32 ssp1_SetClockFreq(u32 frequency) {
	u32 div = PCLK / frequency;
    1e90:	4b09      	ldr	r3, [pc, #36]	; (1eb8 <ssp1_SetClockFreq+0x28>)
    1e92:	fbb3 f0f0 	udiv	r0, r3, r0

  	if (div < 8)    	div = 8;
    1e96:	2807      	cmp	r0, #7
    1e98:	461a      	mov	r2, r3
    1e9a:	d903      	bls.n	1ea4 <ssp1_SetClockFreq+0x14>
    1e9c:	28fe      	cmp	r0, #254	; 0xfe
    1e9e:	bf28      	it	cs
    1ea0:	20fe      	movcs	r0, #254	; 0xfe
    1ea2:	e000      	b.n	1ea6 <ssp1_SetClockFreq+0x16>
    1ea4:	2008      	movs	r0, #8
  	//if (div < 1)    	div = 2;
  	else if (div > 254) div = 254;

  	++div; 
    1ea6:	1c43      	adds	r3, r0, #1
  	div &= ~1;
  	SSP1CPSR = div;
    1ea8:	4904      	ldr	r1, [pc, #16]	; (1ebc <ssp1_SetClockFreq+0x2c>)
  	if (div < 8)    	div = 8;
  	//if (div < 1)    	div = 2;
  	else if (div > 254) div = 254;

  	++div; 
  	div &= ~1;
    1eaa:	f023 0001 	bic.w	r0, r3, #1
  	SSP1CPSR = div;
    1eae:	6008      	str	r0, [r1, #0]
  	plog("SSP1: div       %u"CMD_TERMINATOR, div);
  	plog("SSP1: SSP1CPSR  %u"CMD_TERMINATOR, SSP1CPSR);
  	#endif

  	return (PCLK / div);
}
    1eb0:	fbb2 f0f0 	udiv	r0, r2, r0
    1eb4:	4770      	bx	lr
    1eb6:	bf00      	nop
    1eb8:	017d7840 	.word	0x017d7840
    1ebc:	40030010 	.word	0x40030010

Disassembly of section .text.spp1_SetMode:

00001ec0 <spp1_SetMode>:
int spp1_SetMode ( u8 mode ) {
    n8 status;

    status = pdPASS;

    switch( mode ) {
    1ec0:	b108      	cbz	r0, 1ec6 <spp1_SetMode+0x6>
    1ec2:	2804      	cmp	r0, #4
    1ec4:	d104      	bne.n	1ed0 <spp1_SetMode+0x10>
    	case SSP1_MASTER:
        	SSP1CR1 |= SSP1_MASTER; 				// Mestre
        	break;

    	case SSP1_SLAVE:
    		SSP1CR1 &= ~SSP1_MASTER; 			// escravo
    1ec6:	4b03      	ldr	r3, [pc, #12]	; (1ed4 <spp1_SetMode+0x14>)
// Retorna: 	Retorna pdPASS se a seleção foi feito com sucesso senão retorna código do erro
//------------------------------------------------------------------------------------------------------------------
int spp1_SetMode ( u8 mode ) {
    n8 status;

    status = pdPASS;
    1ec8:	2001      	movs	r0, #1
    	case SSP1_MASTER:
        	SSP1CR1 |= SSP1_MASTER; 				// Mestre
        	break;

    	case SSP1_SLAVE:
    		SSP1CR1 &= ~SSP1_MASTER; 			// escravo
    1eca:	681a      	ldr	r2, [r3, #0]
    1ecc:	601a      	str	r2, [r3, #0]
        	break;
    1ece:	4770      	bx	lr

    	default:
        	status = errSPP1_ERROR_SET_MODE;
    1ed0:	20e1      	movs	r0, #225	; 0xe1
        	break;
    }

    return status;
}
    1ed2:	4770      	bx	lr
    1ed4:	40030004 	.word	0x40030004

Disassembly of section .text.ssp1_Init:

00001ed8 <ssp1_Init>:
//						SSP1_CPOL_L: Clock em baixa entre os frames
//						SSP1_CPOL_H: Clock em alta entre os frames
//					SSP1_STANDARD Tem valor 0x7. Ajusta o modo padrão para a SSP, ou seja, transmissão com 8 bits de transferencia sem interrupção
// Retorna: 	Nada
//------------------------------------------------------------------------------------------------------------------
void ssp1_Init (u8 mode, u16 config) {
    1ed8:	b507      	push	{r0, r1, r2, lr}
  	u32 i;
  	volatile u32 dummy __attribute__ ((unused)); // Usar atributo para não emitir aviso pelo compilador
  	
  	PCONP |= PCSSP1;
    1eda:	4a11      	ldr	r2, [pc, #68]	; (1f20 <ssp1_Init+0x48>)
    1edc:	6813      	ldr	r3, [r2, #0]
    1ede:	f443 6380 	orr.w	r3, r3, #1024	; 0x400
    1ee2:	6013      	str	r3, [r2, #0]
	pinCFG.numPin = SSP1_MISO_NUMPIN;	// Número do pino do ARM para o MISO
	pinsel_configPin(&pinCFG);			// Aplica configurações
	pinCFG.numPin = SSP1_MOSI_NUMPIN;	// Número do pino do ARM para o MOSI
	pinsel_configPin(&pinCFG);			// Aplica configurações
	#else
		ssp1_ConfigPort();
    1ee4:	4a0f      	ldr	r2, [pc, #60]	; (1f24 <ssp1_Init+0x4c>)
    1ee6:	6813      	ldr	r3, [r2, #0]
    1ee8:	f443 2328 	orr.w	r3, r3, #688128	; 0xa8000
    1eec:	6013      	str	r3, [r2, #0]
	#endif
  	#endif

	SSP1CR0  = config; // | SSP1_FRF_SPI;
    1eee:	4b0e      	ldr	r3, [pc, #56]	; (1f28 <ssp1_Init+0x50>)
    1ef0:	6019      	str	r1, [r3, #0]
  	spp1_SetMode( mode );
    1ef2:	f7ff ffe5 	bl	1ec0 <spp1_SetMode>
  	SSP1IMSC = 0x0;
    1ef6:	4b0d      	ldr	r3, [pc, #52]	; (1f2c <ssp1_Init+0x54>)
    1ef8:	2200      	movs	r2, #0
    1efa:	601a      	str	r2, [r3, #0]
  	
  	//  Clock Freq. Identification Mode < 400kHz
  	ssp1_SetClockFreq (400000);
    1efc:	480c      	ldr	r0, [pc, #48]	; (1f30 <ssp1_Init+0x58>)
    1efe:	f7ff ffc7 	bl	1e90 <ssp1_SetClockFreq>

  	//  Enable SPI
  	SSP1CR1 |= SSP1_SSE_ON; // Habilita SSP
    1f02:	4a0c      	ldr	r2, [pc, #48]	; (1f34 <ssp1_Init+0x5c>)
  	plog("SSP1: SSP0CR0 %u"CMD_TERMINATOR, SSP1CR0);
  	plog("SSP1: SSP0CR1 %u"CMD_TERMINATOR, SSP1CR1);
	#endif

  	for (i = 0; i < 8; i++)
    	dummy = SSP1DR;
    1f04:	490c      	ldr	r1, [pc, #48]	; (1f38 <ssp1_Init+0x60>)
  	
  	//  Clock Freq. Identification Mode < 400kHz
  	ssp1_SetClockFreq (400000);

  	//  Enable SPI
  	SSP1CR1 |= SSP1_SSE_ON; // Habilita SSP
    1f06:	6813      	ldr	r3, [r2, #0]
    1f08:	f043 0302 	orr.w	r3, r3, #2
    1f0c:	6013      	str	r3, [r2, #0]
    1f0e:	2308      	movs	r3, #8
  	plog("SSP1: SSP0CR0 %u"CMD_TERMINATOR, SSP1CR0);
  	plog("SSP1: SSP0CR1 %u"CMD_TERMINATOR, SSP1CR1);
	#endif

  	for (i = 0; i < 8; i++)
    	dummy = SSP1DR;
    1f10:	680a      	ldr	r2, [r1, #0]
  	plog("SSP1: INIT"CMD_TERMINATOR);
  	plog("SSP1: SSP0CR0 %u"CMD_TERMINATOR, SSP1CR0);
  	plog("SSP1: SSP0CR1 %u"CMD_TERMINATOR, SSP1CR1);
	#endif

  	for (i = 0; i < 8; i++)
    1f12:	3b01      	subs	r3, #1
    	dummy = SSP1DR;
    1f14:	9201      	str	r2, [sp, #4]
  	plog("SSP1: INIT"CMD_TERMINATOR);
  	plog("SSP1: SSP0CR0 %u"CMD_TERMINATOR, SSP1CR0);
  	plog("SSP1: SSP0CR1 %u"CMD_TERMINATOR, SSP1CR1);
	#endif

  	for (i = 0; i < 8; i++)
    1f16:	d1fb      	bne.n	1f10 <ssp1_Init+0x38>
    	dummy = SSP1DR;
}
    1f18:	b003      	add	sp, #12
    1f1a:	f85d fb04 	ldr.w	pc, [sp], #4
    1f1e:	bf00      	nop
    1f20:	400fc0c4 	.word	0x400fc0c4
    1f24:	4002c000 	.word	0x4002c000
    1f28:	40030000 	.word	0x40030000
    1f2c:	40030014 	.word	0x40030014
    1f30:	00061a80 	.word	0x00061a80
    1f34:	40030004 	.word	0x40030004
    1f38:	40030008 	.word	0x40030008

Disassembly of section .text.ssp1_TransferByte:

00001f3c <ssp1_TransferByte>:
// Descrição: 	Troca de bytes entre os dispositivos
// Parametros:	Byte a ser enviado
// Retorna:		Byte Recebido
//------------------------------------------------------------------------------------------------------------------
u8 ssp1_TransferByte (u8 c) {
	while (!(SSP1SR & SSP1_TNF)); // Espere se a FIFO estiver cheia
    1f3c:	4a06      	ldr	r2, [pc, #24]	; (1f58 <ssp1_TransferByte+0x1c>)
    1f3e:	6813      	ldr	r3, [r2, #0]
    1f40:	4905      	ldr	r1, [pc, #20]	; (1f58 <ssp1_TransferByte+0x1c>)
    1f42:	f013 0f02 	tst.w	r3, #2
    1f46:	d0fa      	beq.n	1f3e <ssp1_TransferByte+0x2>
  	SSP1DR = c;
    1f48:	4b04      	ldr	r3, [pc, #16]	; (1f5c <ssp1_TransferByte+0x20>)
    1f4a:	6018      	str	r0, [r3, #0]
  	while (SSP1SR & SSP1_BSY);
    1f4c:	680a      	ldr	r2, [r1, #0]
    1f4e:	06d2      	lsls	r2, r2, #27
    1f50:	d4fc      	bmi.n	1f4c <ssp1_TransferByte+0x10>

  	return SSP1DR;
    1f52:	6818      	ldr	r0, [r3, #0]
}
    1f54:	b2c0      	uxtb	r0, r0
    1f56:	4770      	bx	lr
    1f58:	4003000c 	.word	0x4003000c
    1f5c:	40030008 	.word	0x40030008

Disassembly of section .text.showVicError:

00001f60 <showVicError>:
#include "vic.h"
#include "app.h"
#include "uart0_irq.h"

static void showVicError(int n) {
    1f60:	e92d 4888 	stmdb	sp!, {r3, r7, fp, lr}
	irq_Disable();
    1f64:	b672      	cpsid	i
    1f66:	280a      	cmp	r0, #10
    1f68:	bfa8      	it	ge
    1f6a:	200a      	movge	r0, #10
    1f6c:	4604      	mov	r4, r0

	static int x;
	if (n>10) n=10;
	while(1) {
		for (x=0;x<n;x++) {
    1f6e:	4d14      	ldr	r5, [pc, #80]	; (1fc0 <showVicError+0x60>)
			ledERROR_On();	buzzer_On();	delay_ms(250);
    1f70:	f8df 905c 	ldr.w	r9, [pc, #92]	; 1fd0 <showVicError+0x70>
	irq_Disable();

	static int x;
	if (n>10) n=10;
	while(1) {
		for (x=0;x<n;x++) {
    1f74:	f04f 0800 	mov.w	r8, #0
    1f78:	f8df a044 	ldr.w	sl, [pc, #68]	; 1fc0 <showVicError+0x60>
			ledERROR_On();	buzzer_On();	delay_ms(250);
    1f7c:	f8df b054 	ldr.w	fp, [pc, #84]	; 1fd4 <showVicError+0x74>
	irq_Disable();

	static int x;
	if (n>10) n=10;
	while(1) {
		for (x=0;x<n;x++) {
    1f80:	f8c5 8000 	str.w	r8, [r5]
    1f84:	f8da 3000 	ldr.w	r3, [sl]
    1f88:	429c      	cmp	r4, r3
    1f8a:	dd15      	ble.n	1fb8 <showVicError+0x58>
			ledERROR_On();	buzzer_On();	delay_ms(250);
    1f8c:	f04f 5700 	mov.w	r7, #536870912	; 0x20000000
    1f90:	f44f 0680 	mov.w	r6, #4194304	; 0x400000
    1f94:	f8c9 7000 	str.w	r7, [r9]
    1f98:	480a      	ldr	r0, [pc, #40]	; (1fc4 <showVicError+0x64>)
    1f9a:	f8cb 6000 	str.w	r6, [fp]
    1f9e:	f7ff fde9 	bl	1b74 <delay>
			ledERROR_Off();	buzzer_Off();	delay_ms(250);
    1fa2:	4b09      	ldr	r3, [pc, #36]	; (1fc8 <showVicError+0x68>)
    1fa4:	4807      	ldr	r0, [pc, #28]	; (1fc4 <showVicError+0x64>)
    1fa6:	601f      	str	r7, [r3, #0]
    1fa8:	f843 6c80 	str.w	r6, [r3, #-128]
    1fac:	f7ff fde2 	bl	1b74 <delay>
	irq_Disable();

	static int x;
	if (n>10) n=10;
	while(1) {
		for (x=0;x<n;x++) {
    1fb0:	682b      	ldr	r3, [r5, #0]
    1fb2:	3301      	adds	r3, #1
    1fb4:	602b      	str	r3, [r5, #0]
    1fb6:	e7e5      	b.n	1f84 <showVicError+0x24>
			ledERROR_On();	buzzer_On();	delay_ms(250);
			ledERROR_Off();	buzzer_Off();	delay_ms(250);
		}
		delay_ms(1000);
    1fb8:	4804      	ldr	r0, [pc, #16]	; (1fcc <showVicError+0x6c>)
    1fba:	f7ff fddb 	bl	1b74 <delay>
	}
    1fbe:	e7db      	b.n	1f78 <showVicError+0x18>
    1fc0:	1000075c 	.word	0x1000075c
    1fc4:	007f26c8 	.word	0x007f26c8
    1fc8:	2009c09c 	.word	0x2009c09c
    1fcc:	01fc9f08 	.word	0x01fc9f08
    1fd0:	2009c098 	.word	0x2009c098
    1fd4:	2009c018 	.word	0x2009c018

Disassembly of section .text.startup.main:

00001fd8 <main>:
}

int main(void) {
    1fd8:	b508      	push	{r3, lr}
	nvic_SetIntHandler(showVicError);
    1fda:	481f      	ldr	r0, [pc, #124]	; (2058 <main+0x80>)
    1fdc:	f7ff fd5a 	bl	1a94 <nvic_SetIntHandler>
	// NÃO USAR UART COM INTERRUPÇÃO PARA O LOG, POIS CONSTANTEMENTE A
  	// POSIÇÃO DOS VETORES DE INTERRUPÇÕES COM O USO DO BOOTLOADER

  	// REGISTRANDO AS ENTRADAS E SAÍDAS PADRÃO AOS SEUS RESPECTIVOS DISPOSTIVOS
	// PORTA PARA CLI DEVE SER COM INTERRUPÇÃO
  	lgetchar_RegisterDev(uart0_GetChar);
    1fe0:	481e      	ldr	r0, [pc, #120]	; (205c <main+0x84>)
    1fe2:	f000 ff27 	bl	2e34 <lgetchar_RegisterDev>
	lputchar_RegisterDev(uart0_PutChar);
    1fe6:	481e      	ldr	r0, [pc, #120]	; (2060 <main+0x88>)
    1fe8:	f000 ff18 	bl	2e1c <lputchar_RegisterDev>
	ldebug_RegisterDev(uart0_BasicPutChar);
    1fec:	481d      	ldr	r0, [pc, #116]	; (2064 <main+0x8c>)
    1fee:	f000 ff1b 	bl	2e28 <ldebug_RegisterDev>
	uart0_Init(115200);
    1ff2:	f44f 30e1 	mov.w	r0, #115200	; 0x1c200
    1ff6:	f7ff fe39 	bl	1c6c <uart0_Init>

	systime_Init();
    1ffa:	f7ff fd51 	bl	1aa0 <systime_Init>
	systime_SetIntHandler(app_Tick, 1); // Chamar o a função callsystem a cada 1ms OBS: Levando em consideração o SYSTIME_IRQ_TICK_DIV
    1ffe:	2101      	movs	r1, #1
    2000:	4819      	ldr	r0, [pc, #100]	; (2068 <main+0x90>)
    2002:	f7ff fd7b 	bl	1afc <systime_SetIntHandler>
	ledError_Init();
    2006:	f001 f9db 	bl	33c0 <ledError_Init>
	beep_Init();
    200a:	f001 fae1 	bl	35d0 <beep_Init>
	gKey_Init(onKeyDown, &onKeyPress, &onKeyUp);	// Anexar os eventos do teclado
    200e:	4a17      	ldr	r2, [pc, #92]	; (206c <main+0x94>)
    2010:	4917      	ldr	r1, [pc, #92]	; (2070 <main+0x98>)
    2012:	4818      	ldr	r0, [pc, #96]	; (2074 <main+0x9c>)
    2014:	f001 fa28 	bl	3468 <gKey_Init>

	ssp1_Init(SSP0_MASTER, SSP0_STANDARD); // inicar o barramento SPI a 400Khz
    2018:	2107      	movs	r1, #7
    201a:	2000      	movs	r0, #0
    201c:	f7ff ff5c 	bl	1ed8 <ssp1_Init>
	ssp1_SetClockFreq(10000000); // 10MHz
    2020:	4815      	ldr	r0, [pc, #84]	; (2078 <main+0xa0>)
    2022:	f7ff ff35 	bl	1e90 <ssp1_SetClockFreq>

	irq_Enable(); 	// Habilitar interrupções
    2026:	b662      	cpsie	i
	app_Init();
    2028:	f000 fc04 	bl	2834 <app_Init>

	lprintf(CMD_TERMINATOR);
    202c:	4913      	ldr	r1, [pc, #76]	; (207c <main+0xa4>)
    202e:	2001      	movs	r0, #1
    2030:	f001 f8c8 	bl	31c4 <rprintf>
	lprintf(PROGAM_NAME);
    2034:	4912      	ldr	r1, [pc, #72]	; (2080 <main+0xa8>)
    2036:	2001      	movs	r0, #1
    2038:	f001 f8c4 	bl	31c4 <rprintf>
	lprintf("ucLibc version "__VERSION CMD_TERMINATOR);
    203c:	4911      	ldr	r1, [pc, #68]	; (2084 <main+0xac>)
    203e:	2001      	movs	r0, #1
    2040:	f001 f8c0 	bl	31c4 <rprintf>

	while (1) {
		prompt_Process();
		app_Process();
		gKey_Process(control.key); // se há tecla pressiona o processo vai chamar os onKeyXXXX
    2044:	4c10      	ldr	r4, [pc, #64]	; (2088 <main+0xb0>)
	lprintf(CMD_TERMINATOR);
	lprintf(PROGAM_NAME);
	lprintf("ucLibc version "__VERSION CMD_TERMINATOR);

	while (1) {
		prompt_Process();
    2046:	f000 fd99 	bl	2b7c <prompt_Process>
		app_Process();
    204a:	f000 fc65 	bl	2918 <app_Process>
		gKey_Process(control.key); // se há tecla pressiona o processo vai chamar os onKeyXXXX
    204e:	7920      	ldrb	r0, [r4, #4]
    2050:	f001 fa26 	bl	34a0 <gKey_Process>
    2054:	e7f7      	b.n	2046 <main+0x6e>
    2056:	bf00      	nop
    2058:	00001f61 	.word	0x00001f61
    205c:	00001d15 	.word	0x00001d15
    2060:	00001d59 	.word	0x00001d59
    2064:	00001dc1 	.word	0x00001dc1
    2068:	00002875 	.word	0x00002875
    206c:	0000275d 	.word	0x0000275d
    2070:	00002745 	.word	0x00002745
    2074:	00002711 	.word	0x00002711
    2078:	00989680 	.word	0x00989680
    207c:	000059ed 	.word	0x000059ed
    2080:	00004eb0 	.word	0x00004eb0
    2084:	0000a3f0 	.word	0x0000a3f0
    2088:	100005dc 	.word	0x100005dc

Disassembly of section .text.drawFrame:

0000208c <drawFrame>:
#define GREENBUTTON_X (REDBUTTON_X + REDBUTTON_W)
#define GREENBUTTON_Y FRAME_Y
#define GREENBUTTON_W (FRAME_W/2)
#define GREENBUTTON_H FRAME_H

static void drawFrame(void) {
    208c:	b507      	push	{r0, r1, r2, lr}
  	gfx_DrawRect(FRAME_X, FRAME_Y, FRAME_W, FRAME_H, clBlack);
    208e:	2300      	movs	r3, #0
    2090:	9300      	str	r3, [sp, #0]
    2092:	2264      	movs	r2, #100	; 0x64
    2094:	2332      	movs	r3, #50	; 0x32
    2096:	21b4      	movs	r1, #180	; 0xb4
    2098:	20d2      	movs	r0, #210	; 0xd2
    209a:	f002 f815 	bl	40c8 <gfx_DrawRect>
}
    209e:	b003      	add	sp, #12
    20a0:	f85d fb04 	ldr.w	pc, [sp], #4

Disassembly of section .text.tft_BackLight:

000020a4 <tft_BackLight>:
#include "app.h"

// #######################################################################################################
// TFT
// #######################################################################################################
void tft_BackLight(int st) {
    20a4:	f04f 5380 	mov.w	r3, #268435456	; 0x10000000
	if (st) ledB_On(); else ledB_Off();
    20a8:	b108      	cbz	r0, 20ae <tft_BackLight+0xa>
    20aa:	4a02      	ldr	r2, [pc, #8]	; (20b4 <tft_BackLight+0x10>)
    20ac:	e000      	b.n	20b0 <tft_BackLight+0xc>
    20ae:	4a02      	ldr	r2, [pc, #8]	; (20b8 <tft_BackLight+0x14>)
    20b0:	6013      	str	r3, [r2, #0]
    20b2:	4770      	bx	lr
    20b4:	2009c038 	.word	0x2009c038
    20b8:	2009c03c 	.word	0x2009c03c

Disassembly of section .text.test_FillScreen:

000020bc <test_FillScreen>:
}

#define MY_DELAY 500
void test_FillScreen(void) {
    20bc:	b510      	push	{r4, lr}
  	//unsigned long start = micros();
  	tft_FillScreen(clBlack);
  	delay_ms(MY_DELAY);
    20be:	4c11      	ldr	r4, [pc, #68]	; (2104 <test_FillScreen+0x48>)
}

#define MY_DELAY 500
void test_FillScreen(void) {
  	//unsigned long start = micros();
  	tft_FillScreen(clBlack);
    20c0:	2000      	movs	r0, #0
    20c2:	f001 fef3 	bl	3eac <tft_FillScreen>
  	delay_ms(MY_DELAY);
    20c6:	4620      	mov	r0, r4
    20c8:	f7ff fd54 	bl	1b74 <delay>
  	tft_FillScreen(clRed);
    20cc:	f44f 4078 	mov.w	r0, #63488	; 0xf800
    20d0:	f001 feec 	bl	3eac <tft_FillScreen>
  	delay_ms(MY_DELAY);
    20d4:	4620      	mov	r0, r4
    20d6:	f7ff fd4d 	bl	1b74 <delay>
  	tft_FillScreen(clGreen);
    20da:	f44f 60fc 	mov.w	r0, #2016	; 0x7e0
    20de:	f001 fee5 	bl	3eac <tft_FillScreen>
  	delay_ms(MY_DELAY);
    20e2:	4620      	mov	r0, r4
    20e4:	f7ff fd46 	bl	1b74 <delay>
  	tft_FillScreen(clBlue);
    20e8:	201f      	movs	r0, #31
    20ea:	f001 fedf 	bl	3eac <tft_FillScreen>
  	delay_ms(MY_DELAY);
    20ee:	4620      	mov	r0, r4
    20f0:	f7ff fd40 	bl	1b74 <delay>
  	tft_FillScreen(clBlack);
    20f4:	2000      	movs	r0, #0
    20f6:	f001 fed9 	bl	3eac <tft_FillScreen>
  	delay_ms(MY_DELAY);
    20fa:	4620      	mov	r0, r4
//  return micros() - start;
}
    20fc:	e8bd 4010 	ldmia.w	sp!, {r4, lr}
  	tft_FillScreen(clGreen);
  	delay_ms(MY_DELAY);
  	tft_FillScreen(clBlue);
  	delay_ms(MY_DELAY);
  	tft_FillScreen(clBlack);
  	delay_ms(MY_DELAY);
    2100:	f7ff bd38 	b.w	1b74 <delay>
    2104:	00fe4d90 	.word	0x00fe4d90

Disassembly of section .text.test_FastLines:

00002108 <test_FastLines>:
//  return micros() - start;
}

void test_FastLines(u16 color1, u16 color2) {
    2108:	e92d 43f8 	stmdb	sp!, {r3, r4, r5, r6, r7, r8, r9, lr}
    210c:	460f      	mov	r7, r1
    210e:	4680      	mov	r8, r0
  	//unsigned long start;
  	int x, y;
  	int w = tft_Width();
    2110:	f001 ff12 	bl	3f38 <tft_Width>
    2114:	4606      	mov	r6, r0
  	int h = tft_Height();
    2116:	f001 ff15 	bl	3f44 <tft_Height>
    211a:	4605      	mov	r5, r0

  	tft_FillScreen(clBlack);
    211c:	2000      	movs	r0, #0
    211e:	f001 fec5 	bl	3eac <tft_FillScreen>
  	//start = micros();
  	for(y=0; y<h; y+=5) tft_DrawFastHLine(0, y, w, color1);
    2122:	2400      	movs	r4, #0
    2124:	fa0f f986 	sxth.w	r9, r6
    2128:	42ac      	cmp	r4, r5
    212a:	da07      	bge.n	213c <test_FastLines+0x34>
    212c:	b221      	sxth	r1, r4
    212e:	4643      	mov	r3, r8
    2130:	464a      	mov	r2, r9
    2132:	2000      	movs	r0, #0
    2134:	f001 fe34 	bl	3da0 <tft_DrawFastHLine>
    2138:	3405      	adds	r4, #5
    213a:	e7f5      	b.n	2128 <test_FastLines+0x20>
    213c:	2400      	movs	r4, #0
  	for(x=0; x<w; x+=5) tft_DrawFastVLine(x, 0, h, color2);
    213e:	b22d      	sxth	r5, r5
    2140:	42b4      	cmp	r4, r6
    2142:	da07      	bge.n	2154 <test_FastLines+0x4c>
    2144:	b220      	sxth	r0, r4
    2146:	463b      	mov	r3, r7
    2148:	462a      	mov	r2, r5
    214a:	2100      	movs	r1, #0
    214c:	f001 fdf0 	bl	3d30 <tft_DrawFastVLine>
    2150:	3405      	adds	r4, #5
    2152:	e7f5      	b.n	2140 <test_FastLines+0x38>

  	//return micros() - start;
}
    2154:	e8bd 83f8 	ldmia.w	sp!, {r3, r4, r5, r6, r7, r8, r9, pc}

Disassembly of section .text.test_Lines:

00002158 <test_Lines>:

void test_Lines(u16 color) {
    2158:	e92d 43f7 	stmdb	sp!, {r0, r1, r2, r4, r5, r6, r7, r8, r9, lr}
    215c:	4604      	mov	r4, r0
  	//unsigned long start, t;
  	int           x1, y1, x2, y2,
    	          w = tft_Width(),
    215e:	f001 feeb 	bl	3f38 <tft_Width>
    2162:	4680      	mov	r8, r0
        	      h = tft_Height();
    2164:	f001 feee 	bl	3f44 <tft_Height>
    2168:	4607      	mov	r7, r0

  	tft_FillScreen(clBlack);
    216a:	2000      	movs	r0, #0
    216c:	f001 fe9e 	bl	3eac <tft_FillScreen>
  	//yield();

  	x1 = y1 = 0;
  	y2    = h - 1;
    2170:	1e7d      	subs	r5, r7, #1
  	//start = micros();
  	for(x2=0; x2<w; x2+=6) gfx_DrawLine(x1, y1, x2, y2, color);
    2172:	2600      	movs	r6, #0
    2174:	4546      	cmp	r6, r8
    2176:	da08      	bge.n	218a <test_Lines+0x32>
    2178:	2100      	movs	r1, #0
    217a:	4632      	mov	r2, r6
    217c:	9400      	str	r4, [sp, #0]
    217e:	462b      	mov	r3, r5
    2180:	4608      	mov	r0, r1
    2182:	f001 ff2d 	bl	3fe0 <gfx_DrawLine>
    2186:	3606      	adds	r6, #6
    2188:	e7f4      	b.n	2174 <test_Lines+0x1c>
  	x2    = w - 1;
    218a:	f108 36ff 	add.w	r6, r8, #4294967295
  	for(y2=0; y2<h; y2+=6) gfx_DrawLine(x1, y1, x2, y2, color);
    218e:	f04f 0900 	mov.w	r9, #0
    2192:	45b9      	cmp	r9, r7
    2194:	da09      	bge.n	21aa <test_Lines+0x52>
    2196:	2100      	movs	r1, #0
    2198:	464b      	mov	r3, r9
    219a:	9400      	str	r4, [sp, #0]
    219c:	4632      	mov	r2, r6
    219e:	4608      	mov	r0, r1
    21a0:	f001 ff1e 	bl	3fe0 <gfx_DrawLine>
    21a4:	f109 0906 	add.w	r9, r9, #6
    21a8:	e7f3      	b.n	2192 <test_Lines+0x3a>
  	//t     = micros() - start; // fillScreen doesn't count against timing

  	delay_ms(MY_DELAY);
    21aa:	4834      	ldr	r0, [pc, #208]	; (227c <test_Lines+0x124>)
    21ac:	f7ff fce2 	bl	1b74 <delay>
  	//yield();
  	tft_FillScreen(clBlack);
    21b0:	2000      	movs	r0, #0
    21b2:	f001 fe7b 	bl	3eac <tft_FillScreen>

  	x1    = w - 1;
  	y1    = 0;
  	y2    = h - 1;
  	//start = micros();
  	for(x2=0; x2<w; x2+=6) gfx_DrawLine(x1, y1, x2, y2, color);
    21b6:	f04f 0900 	mov.w	r9, #0
    21ba:	45c1      	cmp	r9, r8
    21bc:	da09      	bge.n	21d2 <test_Lines+0x7a>
    21be:	464a      	mov	r2, r9
    21c0:	9400      	str	r4, [sp, #0]
    21c2:	462b      	mov	r3, r5
    21c4:	2100      	movs	r1, #0
    21c6:	4630      	mov	r0, r6
    21c8:	f001 ff0a 	bl	3fe0 <gfx_DrawLine>
    21cc:	f109 0906 	add.w	r9, r9, #6
    21d0:	e7f3      	b.n	21ba <test_Lines+0x62>
    21d2:	f04f 0900 	mov.w	r9, #0
  	x2    = 0;
  	for(y2=0; y2<h; y2+=6) gfx_DrawLine(x1, y1, x2, y2, color);
    21d6:	45b9      	cmp	r9, r7
    21d8:	da09      	bge.n	21ee <test_Lines+0x96>
    21da:	2200      	movs	r2, #0
    21dc:	464b      	mov	r3, r9
    21de:	9400      	str	r4, [sp, #0]
    21e0:	4611      	mov	r1, r2
    21e2:	4630      	mov	r0, r6
    21e4:	f001 fefc 	bl	3fe0 <gfx_DrawLine>
    21e8:	f109 0906 	add.w	r9, r9, #6
    21ec:	e7f3      	b.n	21d6 <test_Lines+0x7e>
  	//t    += micros() - start;

  	delay_ms(MY_DELAY);
    21ee:	4823      	ldr	r0, [pc, #140]	; (227c <test_Lines+0x124>)
    21f0:	f7ff fcc0 	bl	1b74 <delay>
  	//yield();
  	tft_FillScreen(clBlack);
    21f4:	2000      	movs	r0, #0
    21f6:	f001 fe59 	bl	3eac <tft_FillScreen>

  	x1    = 0;
  	y1    = h - 1;
  	y2    = 0;
  	//start = micros();
  	for(x2=0; x2<w; x2+=6) gfx_DrawLine(x1, y1, x2, y2, color);
    21fa:	f04f 0900 	mov.w	r9, #0
    21fe:	45c1      	cmp	r9, r8
    2200:	da09      	bge.n	2216 <test_Lines+0xbe>
    2202:	2300      	movs	r3, #0
    2204:	464a      	mov	r2, r9
    2206:	9400      	str	r4, [sp, #0]
    2208:	4629      	mov	r1, r5
    220a:	4618      	mov	r0, r3
    220c:	f001 fee8 	bl	3fe0 <gfx_DrawLine>
    2210:	f109 0906 	add.w	r9, r9, #6
    2214:	e7f3      	b.n	21fe <test_Lines+0xa6>
    2216:	f04f 0900 	mov.w	r9, #0
  	x2    = w - 1;
  	for(y2=0; y2<h; y2+=6) gfx_DrawLine(x1, y1, x2, y2, color);
    221a:	45b9      	cmp	r9, r7
    221c:	da09      	bge.n	2232 <test_Lines+0xda>
    221e:	464b      	mov	r3, r9
    2220:	9400      	str	r4, [sp, #0]
    2222:	4632      	mov	r2, r6
    2224:	4629      	mov	r1, r5
    2226:	2000      	movs	r0, #0
    2228:	f001 feda 	bl	3fe0 <gfx_DrawLine>
    222c:	f109 0906 	add.w	r9, r9, #6
    2230:	e7f3      	b.n	221a <test_Lines+0xc2>
  	//t    += micros() - start;

  	delay_ms(MY_DELAY);
    2232:	4812      	ldr	r0, [pc, #72]	; (227c <test_Lines+0x124>)
    2234:	f7ff fc9e 	bl	1b74 <delay>
  	//yield();
  	tft_FillScreen(clBlack);
    2238:	2000      	movs	r0, #0
    223a:	f001 fe37 	bl	3eac <tft_FillScreen>

  	x1    = w - 1;
  	y1    = h - 1;
  	y2    = 0;
  	//start = micros();
  	for(x2=0; x2<w; x2+=6) gfx_DrawLine(x1, y1, x2, y2, color);
    223e:	f04f 0900 	mov.w	r9, #0
    2242:	45c1      	cmp	r9, r8
    2244:	da09      	bge.n	225a <test_Lines+0x102>
    2246:	464a      	mov	r2, r9
    2248:	9400      	str	r4, [sp, #0]
    224a:	2300      	movs	r3, #0
    224c:	4629      	mov	r1, r5
    224e:	4630      	mov	r0, r6
    2250:	f001 fec6 	bl	3fe0 <gfx_DrawLine>
    2254:	f109 0906 	add.w	r9, r9, #6
    2258:	e7f3      	b.n	2242 <test_Lines+0xea>
    225a:	f04f 0800 	mov.w	r8, #0
  	x2    = 0;
  	for(y2=0; y2<h; y2+=6) gfx_DrawLine(x1, y1, x2, y2, color);
    225e:	45b8      	cmp	r8, r7
    2260:	da09      	bge.n	2276 <test_Lines+0x11e>
    2262:	4643      	mov	r3, r8
    2264:	9400      	str	r4, [sp, #0]
    2266:	2200      	movs	r2, #0
    2268:	4629      	mov	r1, r5
    226a:	4630      	mov	r0, r6
    226c:	f001 feb8 	bl	3fe0 <gfx_DrawLine>
    2270:	f108 0806 	add.w	r8, r8, #6
    2274:	e7f3      	b.n	225e <test_Lines+0x106>

  	//yield();
  	//return micros() - start;

}
    2276:	b003      	add	sp, #12
    2278:	e8bd 83f0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, r9, pc}
    227c:	00fe4d90 	.word	0x00fe4d90

Disassembly of section .text.test_Circles:

00002280 <test_Circles>:

void test_Circles(u8 radius, u16 color) {
    2280:	e92d 47f0 	stmdb	sp!, {r4, r5, r6, r7, r8, r9, sl, lr}
    2284:	4606      	mov	r6, r0
    2286:	468a      	mov	sl, r1
  //unsigned long start;
  int x, y, r2 = radius * 2,
    2288:	0047      	lsls	r7, r0, #1
      w = tft_Width()  + radius,
    228a:	f001 fe55 	bl	3f38 <tft_Width>
    228e:	eb00 0806 	add.w	r8, r0, r6
      h = tft_Height() + radius;
    2292:	f001 fe57 	bl	3f44 <tft_Height>

  // Screen is not cleared for this one -- this is
  // intentional and does not affect the reported time.
  //start = micros();
  	for(x=0; x<w; x+=r2) {
    2296:	2500      	movs	r5, #0

void test_Circles(u8 radius, u16 color) {
  //unsigned long start;
  int x, y, r2 = radius * 2,
      w = tft_Width()  + radius,
      h = tft_Height() + radius;
    2298:	eb00 0906 	add.w	r9, r0, r6

  // Screen is not cleared for this one -- this is
  // intentional and does not affect the reported time.
  //start = micros();
  	for(x=0; x<w; x+=r2) {
    229c:	4545      	cmp	r5, r8
    229e:	da0c      	bge.n	22ba <test_Circles+0x3a>
    22a0:	2400      	movs	r4, #0
    	for(y=0; y<h; y+=r2) {
    22a2:	454c      	cmp	r4, r9
    22a4:	da07      	bge.n	22b6 <test_Circles+0x36>
      		gfx_DrawCircle(x, y, radius, color);
    22a6:	4621      	mov	r1, r4
    22a8:	4653      	mov	r3, sl
    22aa:	4632      	mov	r2, r6
    22ac:	4628      	mov	r0, r5
    22ae:	f002 f807 	bl	42c0 <gfx_DrawCircle>

  // Screen is not cleared for this one -- this is
  // intentional and does not affect the reported time.
  //start = micros();
  	for(x=0; x<w; x+=r2) {
    	for(y=0; y<h; y+=r2) {
    22b2:	443c      	add	r4, r7
    22b4:	e7f5      	b.n	22a2 <test_Circles+0x22>
      h = tft_Height() + radius;

  // Screen is not cleared for this one -- this is
  // intentional and does not affect the reported time.
  //start = micros();
  	for(x=0; x<w; x+=r2) {
    22b6:	443d      	add	r5, r7
    22b8:	e7f0      	b.n	229c <test_Circles+0x1c>
    22ba:	e8bd 87f0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, r9, sl, pc}

Disassembly of section .text.test_FilledCircles:

000022be <test_FilledCircles>:
  	}

  	//return micros() - start;
}

void test_FilledCircles(uint radius, uint color) {
    22be:	e92d 47f0 	stmdb	sp!, {r4, r5, r6, r7, r8, r9, sl, lr}
    22c2:	4605      	mov	r5, r0
    22c4:	4688      	mov	r8, r1
  	//unsigned long start;
  	int x, y, w = tft_Width(), h = tft_Height(), r2 = radius * 2;
    22c6:	f001 fe37 	bl	3f38 <tft_Width>
    22ca:	4681      	mov	r9, r0
    22cc:	f001 fe3a 	bl	3f44 <tft_Height>
    22d0:	4682      	mov	sl, r0

  	tft_FillScreen(clBlack);
    22d2:	2000      	movs	r0, #0
    22d4:	f001 fdea 	bl	3eac <tft_FillScreen>
  	//start = micros();
  	for(x=radius; x<w; x+=r2) {
    22d8:	462e      	mov	r6, r5
  	//return micros() - start;
}

void test_FilledCircles(uint radius, uint color) {
  	//unsigned long start;
  	int x, y, w = tft_Width(), h = tft_Height(), r2 = radius * 2;
    22da:	006f      	lsls	r7, r5, #1

  	tft_FillScreen(clBlack);
  	//start = micros();
  	for(x=radius; x<w; x+=r2) {
    22dc:	454e      	cmp	r6, r9
    22de:	da0c      	bge.n	22fa <test_FilledCircles+0x3c>
    22e0:	462c      	mov	r4, r5
    	for(y=radius; y<h; y+=r2) {
    22e2:	4554      	cmp	r4, sl
    22e4:	da07      	bge.n	22f6 <test_FilledCircles+0x38>
      		gfx_FillCircle(x, y, radius, color);
    22e6:	4621      	mov	r1, r4
    22e8:	4643      	mov	r3, r8
    22ea:	462a      	mov	r2, r5
    22ec:	4630      	mov	r0, r6
    22ee:	f002 f993 	bl	4618 <gfx_FillCircle>
  	int x, y, w = tft_Width(), h = tft_Height(), r2 = radius * 2;

  	tft_FillScreen(clBlack);
  	//start = micros();
  	for(x=radius; x<w; x+=r2) {
    	for(y=radius; y<h; y+=r2) {
    22f2:	443c      	add	r4, r7
    22f4:	e7f5      	b.n	22e2 <test_FilledCircles+0x24>
  	//unsigned long start;
  	int x, y, w = tft_Width(), h = tft_Height(), r2 = radius * 2;

  	tft_FillScreen(clBlack);
  	//start = micros();
  	for(x=radius; x<w; x+=r2) {
    22f6:	443e      	add	r6, r7
    22f8:	e7f0      	b.n	22dc <test_FilledCircles+0x1e>
    22fa:	e8bd 87f0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, r9, sl, pc}

Disassembly of section .text.test_Triangles:

000022fe <test_Triangles>:


  	//return micros() - start;
}

void test_Triangles(void) {
    22fe:	e92d 41ff 	stmdb	sp!, {r0, r1, r2, r3, r4, r5, r6, r7, r8, lr}
  	//unsigned long start;
  	int           n, i, cx = tft_Width()  / 2 - 1,
    2302:	f001 fe19 	bl	3f38 <tft_Width>
    2306:	f3c0 004f 	ubfx	r0, r0, #1, #16
    230a:	1e45      	subs	r5, r0, #1
                      cy = tft_Height() / 2 - 1;
    230c:	f001 fe1a 	bl	3f44 <tft_Height>
    2310:	f3c0 064f 	ubfx	r6, r0, #1, #16

  	tft_FillScreen(clBlack);
  	n     = min(cx, cy);
    2314:	3e01      	subs	r6, #1
void test_Triangles(void) {
  	//unsigned long start;
  	int           n, i, cx = tft_Width()  / 2 - 1,
                      cy = tft_Height() / 2 - 1;

  	tft_FillScreen(clBlack);
    2316:	2000      	movs	r0, #0
    2318:	f001 fdc8 	bl	3eac <tft_FillScreen>
  	n     = min(cx, cy);
    231c:	42ae      	cmp	r6, r5
    231e:	46b0      	mov	r8, r6
    2320:	bfa8      	it	ge
    2322:	46a8      	movge	r8, r5
  	//start = micros();
  	for(i=0; i<n; i+=5) {
    2324:	2400      	movs	r4, #0
    2326:	4544      	cmp	r4, r8
    2328:	da11      	bge.n	234e <test_Triangles+0x50>
    	gfx_DrawTriangle(
      		cx    , cy - i, // peak
      		cx - i, cy + i, // bottom left
      		cx + i, cy + i, // bottom right
      		tft_Color565(i, i, i));
    232a:	b2e2      	uxtb	r2, r4
    232c:	4611      	mov	r1, r2
    232e:	4610      	mov	r0, r2
    2330:	f001 fdd0 	bl	3ed4 <tft_Color565>
    2334:	19a7      	adds	r7, r4, r6

  	tft_FillScreen(clBlack);
  	n     = min(cx, cy);
  	//start = micros();
  	for(i=0; i<n; i+=5) {
    	gfx_DrawTriangle(
    2336:	1963      	adds	r3, r4, r5
    2338:	9002      	str	r0, [sp, #8]
    233a:	9300      	str	r3, [sp, #0]
    233c:	1b2a      	subs	r2, r5, r4
    233e:	1b31      	subs	r1, r6, r4
    2340:	9701      	str	r7, [sp, #4]
    2342:	463b      	mov	r3, r7
    2344:	4628      	mov	r0, r5
    2346:	f001 feed 	bl	4124 <gfx_DrawTriangle>
                      cy = tft_Height() / 2 - 1;

  	tft_FillScreen(clBlack);
  	n     = min(cx, cy);
  	//start = micros();
  	for(i=0; i<n; i+=5) {
    234a:	3405      	adds	r4, #5
    234c:	e7eb      	b.n	2326 <test_Triangles+0x28>
      		cx + i, cy + i, // bottom right
      		tft_Color565(i, i, i));
  	}

  	//return micros() - start;
}
    234e:	b004      	add	sp, #16
    2350:	e8bd 81f0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, pc}

Disassembly of section .text.test_FilledTriangles:

00002354 <test_FilledTriangles>:

void test_FilledTriangles(void) {
    2354:	e92d 4ff0 	stmdb	sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
    2358:	b085      	sub	sp, #20
  	//unsigned long start, t = 0;
  	int           i, cx = tft_Width()  / 2 - 1,
    235a:	f001 fded 	bl	3f38 <tft_Width>
    235e:	f3c0 004f 	ubfx	r0, r0, #1, #16
    2362:	1e47      	subs	r7, r0, #1
                   cy = tft_Height() / 2 - 1;
    2364:	f001 fdee 	bl	3f44 <tft_Height>
    2368:	f3c0 054f 	ubfx	r5, r0, #1, #16

  	tft_FillScreen(clBlack);
  	//start = micros();
  	for(i=min(cx,cy); i>10; i-=5) {
    236c:	3d01      	subs	r5, #1
void test_FilledTriangles(void) {
  	//unsigned long start, t = 0;
  	int           i, cx = tft_Width()  / 2 - 1,
                   cy = tft_Height() / 2 - 1;

  	tft_FillScreen(clBlack);
    236e:	2000      	movs	r0, #0
    2370:	f001 fd9c 	bl	3eac <tft_FillScreen>
  	//start = micros();
  	for(i=min(cx,cy); i>10; i-=5) {
    2374:	42bd      	cmp	r5, r7
    2376:	46a8      	mov	r8, r5
    2378:	bfa8      	it	ge
    237a:	46b8      	movge	r8, r7
    237c:	eb08 0488 	add.w	r4, r8, r8, lsl #2
    2380:	0064      	lsls	r4, r4, #1
    2382:	f1b8 0f0a 	cmp.w	r8, #10
    2386:	b2e4      	uxtb	r4, r4
    2388:	dd29      	ble.n	23de <test_FilledTriangles+0x8a>
    	//start = micros();
    	gfx_FillTriangle(cx, cy - i, cx - i, cy + i, cx + i, cy + i,
      	tft_Color565(0, i*10, i*10));
    238a:	4622      	mov	r2, r4
    238c:	4621      	mov	r1, r4
    238e:	2000      	movs	r0, #0
    2390:	f001 fda0 	bl	3ed4 <tft_Color565>
    2394:	eb08 0605 	add.w	r6, r8, r5
    2398:	ebc8 0905 	rsb	r9, r8, r5
    239c:	ebc8 0a07 	rsb	sl, r8, r7
    23a0:	eb08 0b07 	add.w	fp, r8, r7

  	tft_FillScreen(clBlack);
  	//start = micros();
  	for(i=min(cx,cy); i>10; i-=5) {
    	//start = micros();
    	gfx_FillTriangle(cx, cy - i, cx - i, cy + i, cx + i, cy + i,
    23a4:	4633      	mov	r3, r6
    23a6:	9002      	str	r0, [sp, #8]
    23a8:	4652      	mov	r2, sl
    23aa:	4649      	mov	r1, r9
    23ac:	4638      	mov	r0, r7
    23ae:	9601      	str	r6, [sp, #4]
    23b0:	f8cd b000 	str.w	fp, [sp]
    23b4:	f001 fed3 	bl	415e <gfx_FillTriangle>
      	tft_Color565(0, i*10, i*10));
    	//t += micros() - start;
    	gfx_DrawTriangle(cx, cy - i, cx - i, cy + i, cx + i, cy + i,
      	tft_Color565(i*10, i*10, 0));
    23b8:	4621      	mov	r1, r4
    23ba:	2200      	movs	r2, #0
    23bc:	4620      	mov	r0, r4
    23be:	f001 fd89 	bl	3ed4 <tft_Color565>
  	for(i=min(cx,cy); i>10; i-=5) {
    	//start = micros();
    	gfx_FillTriangle(cx, cy - i, cx - i, cy + i, cx + i, cy + i,
      	tft_Color565(0, i*10, i*10));
    	//t += micros() - start;
    	gfx_DrawTriangle(cx, cy - i, cx - i, cy + i, cx + i, cy + i,
    23c2:	9601      	str	r6, [sp, #4]
    23c4:	9002      	str	r0, [sp, #8]
    23c6:	f8cd b000 	str.w	fp, [sp]
    23ca:	4633      	mov	r3, r6
    23cc:	4652      	mov	r2, sl
    23ce:	4649      	mov	r1, r9
    23d0:	4638      	mov	r0, r7
    23d2:	f001 fea7 	bl	4124 <gfx_DrawTriangle>
  	int           i, cx = tft_Width()  / 2 - 1,
                   cy = tft_Height() / 2 - 1;

  	tft_FillScreen(clBlack);
  	//start = micros();
  	for(i=min(cx,cy); i>10; i-=5) {
    23d6:	f1a8 0805 	sub.w	r8, r8, #5
    23da:	3c32      	subs	r4, #50	; 0x32
    23dc:	e7d1      	b.n	2382 <test_FilledTriangles+0x2e>
      	tft_Color565(i*10, i*10, 0));
    	//yield();
  	}

  	//return t;
}
    23de:	b005      	add	sp, #20
    23e0:	e8bd 8ff0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}

Disassembly of section .text.test_RoundRects:

000023e4 <test_RoundRects>:

void test_RoundRects(void) {
    23e4:	e92d 43f7 	stmdb	sp!, {r0, r1, r2, r4, r5, r6, r7, r8, r9, lr}
  	//unsigned long start;
  	int         w, i, i2,
                cx = tft_Width()  / 2 - 1,
    23e8:	f001 fda6 	bl	3f38 <tft_Width>
    23ec:	f3c0 004f 	ubfx	r0, r0, #1, #16
    23f0:	1e46      	subs	r6, r0, #1
                cy = tft_Height() / 2 - 1;
    23f2:	f001 fda7 	bl	3f44 <tft_Height>
    23f6:	f3c0 004f 	ubfx	r0, r0, #1, #16
    23fa:	1e47      	subs	r7, r0, #1

  	tft_FillScreen(clBlack);
    23fc:	2000      	movs	r0, #0
    23fe:	f001 fd55 	bl	3eac <tft_FillScreen>
  	w     = min(tft_Width(), tft_Height());
    2402:	f001 fd99 	bl	3f38 <tft_Width>
    2406:	4604      	mov	r4, r0
    2408:	f001 fd9c 	bl	3f44 <tft_Height>
    240c:	4284      	cmp	r4, r0
    240e:	d202      	bcs.n	2416 <test_RoundRects+0x32>
    2410:	f001 fd92 	bl	3f38 <tft_Width>
    2414:	e001      	b.n	241a <test_RoundRects+0x36>
    2416:	f001 fd95 	bl	3f44 <tft_Height>
    241a:	4680      	mov	r8, r0
  	//start = micros();
  	for(i=0; i<w; i+=6) {
    241c:	2400      	movs	r4, #0
    241e:	4544      	cmp	r4, r8
    2420:	da13      	bge.n	244a <test_RoundRects+0x66>
    	i2 = i / 2;
    2422:	1061      	asrs	r1, r4, #1
    	gfx_DrawRoundRect(cx-i2, cy-i2, i, i, i/8, tft_Color565(i, 0, 0));
    2424:	2200      	movs	r2, #0
    2426:	ebc1 0906 	rsb	r9, r1, r6
    242a:	1a7d      	subs	r5, r7, r1
    242c:	b2e0      	uxtb	r0, r4
    242e:	4611      	mov	r1, r2
    2430:	f001 fd50 	bl	3ed4 <tft_Color565>
    2434:	10e3      	asrs	r3, r4, #3
    2436:	9001      	str	r0, [sp, #4]
    2438:	9300      	str	r3, [sp, #0]
    243a:	4622      	mov	r2, r4
    243c:	4623      	mov	r3, r4
    243e:	4629      	mov	r1, r5
    2440:	4648      	mov	r0, r9
    2442:	f002 f903 	bl	464c <gfx_DrawRoundRect>
                cy = tft_Height() / 2 - 1;

  	tft_FillScreen(clBlack);
  	w     = min(tft_Width(), tft_Height());
  	//start = micros();
  	for(i=0; i<w; i+=6) {
    2446:	3406      	adds	r4, #6
    2448:	e7e9      	b.n	241e <test_RoundRects+0x3a>
    	i2 = i / 2;
    	gfx_DrawRoundRect(cx-i2, cy-i2, i, i, i/8, tft_Color565(i, 0, 0));
  	}

  	//return micros() - start;
}
    244a:	b003      	add	sp, #12
    244c:	e8bd 83f0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, r9, pc}

Disassembly of section .text.test_FilledRoundRects:

00002450 <test_FilledRoundRects>:

void test_FilledRoundRects(void) {
    2450:	e92d 41f3 	stmdb	sp!, {r0, r1, r4, r5, r6, r7, r8, lr}
	//  unsigned long start;
  	int         i, i2,
                cx = tft_Width()  / 2 - 1,
    2454:	f001 fd70 	bl	3f38 <tft_Width>
    2458:	f3c0 004f 	ubfx	r0, r0, #1, #16
    245c:	1e46      	subs	r6, r0, #1
                cy = tft_Height() / 2 - 1;
    245e:	f001 fd71 	bl	3f44 <tft_Height>
    2462:	f3c0 004f 	ubfx	r0, r0, #1, #16
    2466:	1e47      	subs	r7, r0, #1

  	tft_FillScreen(clBlack);
    2468:	2000      	movs	r0, #0
    246a:	f001 fd1f 	bl	3eac <tft_FillScreen>
  	//start = micros();
  	for(i=min(tft_Width(), tft_Height()); i>20; i-=6) {
    246e:	f001 fd63 	bl	3f38 <tft_Width>
    2472:	4604      	mov	r4, r0
    2474:	f001 fd66 	bl	3f44 <tft_Height>
    2478:	4284      	cmp	r4, r0
    247a:	d202      	bcs.n	2482 <test_FilledRoundRects+0x32>
    247c:	f001 fd5c 	bl	3f38 <tft_Width>
    2480:	e001      	b.n	2486 <test_FilledRoundRects+0x36>
    2482:	f001 fd5f 	bl	3f44 <tft_Height>
    2486:	4604      	mov	r4, r0
    2488:	2c14      	cmp	r4, #20
    248a:	dd13      	ble.n	24b4 <test_FilledRoundRects+0x64>
    	i2 = i / 2;
    248c:	1061      	asrs	r1, r4, #1
    	gfx_FillRoundRect(cx-i2, cy-i2, i, i, i/8, tft_Color565(0, i, 0));
    248e:	2200      	movs	r2, #0
    2490:	ebc1 0806 	rsb	r8, r1, r6
    2494:	1a7d      	subs	r5, r7, r1
    2496:	4610      	mov	r0, r2
    2498:	b2e1      	uxtb	r1, r4
    249a:	f001 fd1b 	bl	3ed4 <tft_Color565>
    249e:	10e3      	asrs	r3, r4, #3
    24a0:	9001      	str	r0, [sp, #4]
    24a2:	9300      	str	r3, [sp, #0]
    24a4:	4622      	mov	r2, r4
    24a6:	4623      	mov	r3, r4
    24a8:	4629      	mov	r1, r5
    24aa:	4640      	mov	r0, r8
    24ac:	f002 f944 	bl	4738 <gfx_FillRoundRect>
                cx = tft_Width()  / 2 - 1,
                cy = tft_Height() / 2 - 1;

  	tft_FillScreen(clBlack);
  	//start = micros();
  	for(i=min(tft_Width(), tft_Height()); i>20; i-=6) {
    24b0:	3c06      	subs	r4, #6
    24b2:	e7e9      	b.n	2488 <test_FilledRoundRects+0x38>
    	gfx_FillRoundRect(cx-i2, cy-i2, i, i, i/8, tft_Color565(0, i, 0));
    	//yield();
  	}

//  return micros() - start;
}
    24b4:	b002      	add	sp, #8
    24b6:	e8bd 81f0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, pc}

Disassembly of section .text.test_Rects:

000024ba <test_Rects>:

void test_Rects(uint color) {
    24ba:	e92d 41f3 	stmdb	sp!, {r0, r1, r4, r5, r6, r7, r8, lr}
    24be:	4680      	mov	r8, r0
  	//unsigned long start;
  	int           n, i, i2,
                cx = tft_Width()  / 2,
    24c0:	f001 fd3a 	bl	3f38 <tft_Width>
    24c4:	f3c0 064f 	ubfx	r6, r0, #1, #16
                cy = tft_Height() / 2;
    24c8:	f001 fd3c 	bl	3f44 <tft_Height>
    24cc:	f3c0 074f 	ubfx	r7, r0, #1, #16

  	tft_FillScreen(clBlack);
    24d0:	2000      	movs	r0, #0
    24d2:	f001 fceb 	bl	3eac <tft_FillScreen>
  	n     = min(tft_Width(), tft_Height());
    24d6:	f001 fd2f 	bl	3f38 <tft_Width>
    24da:	4604      	mov	r4, r0
    24dc:	f001 fd32 	bl	3f44 <tft_Height>
    24e0:	4284      	cmp	r4, r0
    24e2:	d202      	bcs.n	24ea <test_Rects+0x30>
    24e4:	f001 fd28 	bl	3f38 <tft_Width>
    24e8:	e001      	b.n	24ee <test_Rects+0x34>
    24ea:	f001 fd2b 	bl	3f44 <tft_Height>
    24ee:	4605      	mov	r5, r0
  	//start = micros();
  	for(i=2; i<n; i+=6) {
    24f0:	2402      	movs	r4, #2
    24f2:	42ac      	cmp	r4, r5
    24f4:	da0a      	bge.n	250c <test_Rects+0x52>
    	i2 = i / 2;
    24f6:	1060      	asrs	r0, r4, #1
    	gfx_DrawRect(cx-i2, cy-i2, i, i, color);
    24f8:	4623      	mov	r3, r4
    24fa:	4622      	mov	r2, r4
    24fc:	1a39      	subs	r1, r7, r0
    24fe:	f8cd 8000 	str.w	r8, [sp]
    2502:	1a30      	subs	r0, r6, r0
    2504:	f001 fde0 	bl	40c8 <gfx_DrawRect>
                cy = tft_Height() / 2;

  	tft_FillScreen(clBlack);
  	n     = min(tft_Width(), tft_Height());
  	//start = micros();
  	for(i=2; i<n; i+=6) {
    2508:	3406      	adds	r4, #6
    250a:	e7f2      	b.n	24f2 <test_Rects+0x38>
    	i2 = i / 2;
    	gfx_DrawRect(cx-i2, cy-i2, i, i, color);
  	}

  	//return micros() - start;
}
    250c:	b002      	add	sp, #8
    250e:	e8bd 81f0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, pc}

Disassembly of section .text.test_FilledRects:

00002512 <test_FilledRects>:

void test_FilledRects(uint color1, uint color2) {
    2512:	e92d 47f3 	stmdb	sp!, {r0, r1, r4, r5, r6, r7, r8, r9, sl, lr}
    2516:	468a      	mov	sl, r1
    2518:	4681      	mov	r9, r0
  	//unsigned long start, t = 0;
  	int           n, i, i2,
                cx = tft_Width()  / 2 - 1,
    251a:	f001 fd0d 	bl	3f38 <tft_Width>
    251e:	f3c0 004f 	ubfx	r0, r0, #1, #16
    2522:	1e46      	subs	r6, r0, #1
                cy = tft_Height() / 2 - 1;
    2524:	f001 fd0e 	bl	3f44 <tft_Height>
    2528:	f3c0 004f 	ubfx	r0, r0, #1, #16
    252c:	1e47      	subs	r7, r0, #1

  	tft_FillScreen(clBlack);
    252e:	2000      	movs	r0, #0
    2530:	f001 fcbc 	bl	3eac <tft_FillScreen>
  	n = min(tft_Width(), tft_Height());
    2534:	f001 fd00 	bl	3f38 <tft_Width>
    2538:	4604      	mov	r4, r0
    253a:	f001 fd03 	bl	3f44 <tft_Height>
    253e:	4284      	cmp	r4, r0
    2540:	d202      	bcs.n	2548 <test_FilledRects+0x36>
    2542:	f001 fcf9 	bl	3f38 <tft_Width>
    2546:	e001      	b.n	254c <test_FilledRects+0x3a>
    2548:	f001 fcfc 	bl	3f44 <tft_Height>
    254c:	4604      	mov	r4, r0
  	for(i=n; i>0; i-=6) {
    254e:	2c00      	cmp	r4, #0
    2550:	dd15      	ble.n	257e <test_FilledRects+0x6c>
    	i2    = i / 2;
    2552:	1065      	asrs	r5, r4, #1
    	//start = micros();
    	gfx_FillRect(cx-i2, cy-i2, i, i, color1);
    2554:	ebc5 0806 	rsb	r8, r5, r6
    2558:	1b7d      	subs	r5, r7, r5
    255a:	4623      	mov	r3, r4
    255c:	4622      	mov	r2, r4
    255e:	4629      	mov	r1, r5
    2560:	4640      	mov	r0, r8
    2562:	f8cd 9000 	str.w	r9, [sp]
    2566:	f001 fd87 	bl	4078 <gfx_FillRect>
    	//t    += micros() - start;
    	// Outlines are not included in timing results
    	gfx_DrawRect(cx-i2, cy-i2, i, i, color2);
    256a:	4623      	mov	r3, r4
    256c:	4622      	mov	r2, r4
    256e:	f8cd a000 	str.w	sl, [sp]
    2572:	4629      	mov	r1, r5
    2574:	4640      	mov	r0, r8
    2576:	f001 fda7 	bl	40c8 <gfx_DrawRect>
                cx = tft_Width()  / 2 - 1,
                cy = tft_Height() / 2 - 1;

  	tft_FillScreen(clBlack);
  	n = min(tft_Width(), tft_Height());
  	for(i=n; i>0; i-=6) {
    257a:	3c06      	subs	r4, #6
    257c:	e7e7      	b.n	254e <test_FilledRects+0x3c>
    	gfx_DrawRect(cx-i2, cy-i2, i, i, color2);
    	//yield();
  	}

  	//return t;
}
    257e:	b002      	add	sp, #8
    2580:	e8bd 87f0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, r9, sl, pc}

Disassembly of section .text.test_Buttons:

00002584 <test_Buttons>:
  gfx_SetTextSize(2);
  gfx_printf("OFF");
  //RecordOn = true;
}

void test_Buttons(void) {
    2584:	b537      	push	{r0, r1, r2, r4, r5, lr}
  	gfx_FillScreen(clBlue);
    2586:	201f      	movs	r0, #31
    2588:	f001 fd8c 	bl	40a4 <gfx_FillScreen>
  	gfx_SetRotation(1);
    258c:	2001      	movs	r0, #1
    258e:	f001 fd0b 	bl	3fa8 <gfx_SetRotation>
    2592:	240a      	movs	r4, #10
  	gfx_DrawRect(FRAME_X, FRAME_Y, FRAME_W, FRAME_H, clBlack);
}


static void redBtn(void) {
  gfx_FillRect(REDBUTTON_X, REDBUTTON_Y, REDBUTTON_W, REDBUTTON_H, clRed);
    2594:	f44f 4378 	mov.w	r3, #63488	; 0xf800
    2598:	9300      	str	r3, [sp, #0]
    259a:	2332      	movs	r3, #50	; 0x32
    259c:	461a      	mov	r2, r3
    259e:	21b4      	movs	r1, #180	; 0xb4
    25a0:	20d2      	movs	r0, #210	; 0xd2
    25a2:	f001 fd69 	bl	4078 <gfx_FillRect>
  gfx_FillRect(GREENBUTTON_X, GREENBUTTON_Y, GREENBUTTON_W, GREENBUTTON_H, clBlue);
    25a6:	251f      	movs	r5, #31
    25a8:	2332      	movs	r3, #50	; 0x32
    25aa:	461a      	mov	r2, r3
    25ac:	21b4      	movs	r1, #180	; 0xb4
    25ae:	f44f 7082 	mov.w	r0, #260	; 0x104
    25b2:	9500      	str	r5, [sp, #0]
    25b4:	f001 fd60 	bl	4078 <gfx_FillRect>
  drawFrame();
    25b8:	f7ff fd68 	bl	208c <drawFrame>
  gfx_SetCursor(GREENBUTTON_X + 6 , GREENBUTTON_Y + (GREENBUTTON_H/2));
    25bc:	21cd      	movs	r1, #205	; 0xcd
    25be:	f44f 7085 	mov.w	r0, #266	; 0x10a
    25c2:	f002 f8e9 	bl	4798 <gfx_SetCursor>
  gfx_SetTextColor(clWhite);
    25c6:	f64f 70ff 	movw	r0, #65535	; 0xffff
    25ca:	f002 f8f7 	bl	47bc <gfx_SetTextColor>
  gfx_SetTextSize(2);
    25ce:	2002      	movs	r0, #2
    25d0:	f002 f8ec 	bl	47ac <gfx_SetTextSize>
  gfx_printf("ON");
    25d4:	4816      	ldr	r0, [pc, #88]	; (2630 <test_Buttons+0xac>)
    25d6:	f002 f9e1 	bl	499c <gfx_printf>

void test_Buttons(void) {
  	gfx_FillScreen(clBlue);
  	gfx_SetRotation(1);
  	int x; for(x=0; x<10; x++) {
  		redBtn(); delay_ms(500);
    25da:	4816      	ldr	r0, [pc, #88]	; (2634 <test_Buttons+0xb0>)
    25dc:	f7ff faca 	bl	1b74 <delay>
  gfx_printf("ON");
  //RecordOn = false;
}

static void greenBtn(void) {
  gfx_FillRect(GREENBUTTON_X, GREENBUTTON_Y, GREENBUTTON_W, GREENBUTTON_H, clGreen);
    25e0:	f44f 63fc 	mov.w	r3, #2016	; 0x7e0
    25e4:	9300      	str	r3, [sp, #0]
    25e6:	2332      	movs	r3, #50	; 0x32
    25e8:	461a      	mov	r2, r3
    25ea:	21b4      	movs	r1, #180	; 0xb4
    25ec:	f44f 7082 	mov.w	r0, #260	; 0x104
    25f0:	f001 fd42 	bl	4078 <gfx_FillRect>
  gfx_FillRect(REDBUTTON_X, REDBUTTON_Y, REDBUTTON_W, REDBUTTON_H, clBlue);
    25f4:	2332      	movs	r3, #50	; 0x32
    25f6:	461a      	mov	r2, r3
    25f8:	21b4      	movs	r1, #180	; 0xb4
    25fa:	20d2      	movs	r0, #210	; 0xd2
    25fc:	9500      	str	r5, [sp, #0]
    25fe:	f001 fd3b 	bl	4078 <gfx_FillRect>
  drawFrame();
    2602:	f7ff fd43 	bl	208c <drawFrame>
  gfx_SetCursor(REDBUTTON_X + 6 , REDBUTTON_Y + (REDBUTTON_H/2));
    2606:	21cd      	movs	r1, #205	; 0xcd
    2608:	20d8      	movs	r0, #216	; 0xd8
    260a:	f002 f8c5 	bl	4798 <gfx_SetCursor>
  gfx_SetTextColor(clWhite);
    260e:	f64f 70ff 	movw	r0, #65535	; 0xffff
    2612:	f002 f8d3 	bl	47bc <gfx_SetTextColor>
  gfx_SetTextSize(2);
    2616:	2002      	movs	r0, #2
    2618:	f002 f8c8 	bl	47ac <gfx_SetTextSize>
  gfx_printf("OFF");
    261c:	4806      	ldr	r0, [pc, #24]	; (2638 <test_Buttons+0xb4>)
    261e:	f002 f9bd 	bl	499c <gfx_printf>
void test_Buttons(void) {
  	gfx_FillScreen(clBlue);
  	gfx_SetRotation(1);
  	int x; for(x=0; x<10; x++) {
  		redBtn(); delay_ms(500);
  		greenBtn(); delay_ms(500);
    2622:	4804      	ldr	r0, [pc, #16]	; (2634 <test_Buttons+0xb0>)
    2624:	f7ff faa6 	bl	1b74 <delay>
}

void test_Buttons(void) {
  	gfx_FillScreen(clBlue);
  	gfx_SetRotation(1);
  	int x; for(x=0; x<10; x++) {
    2628:	3c01      	subs	r4, #1
    262a:	d1b3      	bne.n	2594 <test_Buttons+0x10>
  		redBtn(); delay_ms(500);
  		greenBtn(); delay_ms(500);
  	}
}
    262c:	b003      	add	sp, #12
    262e:	bd30      	pop	{r4, r5, pc}
    2630:	0000597c 	.word	0x0000597c
    2634:	00fe4d90 	.word	0x00fe4d90
    2638:	0000597f 	.word	0x0000597f

Disassembly of section .text.test_Printf:

0000263c <test_Printf>:
//#include "font_SerifBold24pt7b.h"
#include "font_SansBoldOblique18pt7b.h"
#include "font_SansOblique24pt7b.h"
#include "font_tomThumb.h"

void test_Printf(void) {
    263c:	b538      	push	{r3, r4, r5, lr}
	tft_FillScreen(clBlack);
    263e:	2000      	movs	r0, #0
    2640:	f001 fc34 	bl	3eac <tft_FillScreen>
	gfx_SetRotation(1);
    2644:	2001      	movs	r0, #1
    2646:	f001 fcaf 	bl	3fa8 <gfx_SetRotation>
  	rprintf_RegisterDev(STDIO_DEV3, gfx_PutChar);
    264a:	491f      	ldr	r1, [pc, #124]	; (26c8 <test_Printf+0x8c>)
    264c:	2006      	movs	r0, #6
    264e:	f000 fbcd 	bl	2dec <rprintf_RegisterDev>

  	gfx_SetFont(&sansBoldOblique18pt7b);
    2652:	481e      	ldr	r0, [pc, #120]	; (26cc <test_Printf+0x90>)
    2654:	f002 f992 	bl	497c <gfx_SetFont>
  	gfx_SetCursor(0, 0);
    2658:	2100      	movs	r1, #0
    265a:	4608      	mov	r0, r1
    265c:	f002 f89c 	bl	4798 <gfx_SetCursor>
  	gfx_PutChar('\n');
    2660:	200a      	movs	r0, #10
    2662:	f002 f92d 	bl	48c0 <gfx_PutChar>
  	gfx_SetTextColor(clWhite);
    2666:	f64f 70ff 	movw	r0, #65535	; 0xffff
    266a:	f002 f8a7 	bl	47bc <gfx_SetTextColor>
  	gfx_SetTextSize(1);
  	rprintf(STDIO_DEV3, "Ola mundo"CMD_TERMINATOR);
	gfx_printf(CMD_TERMINATOR);
    266e:	4c18      	ldr	r4, [pc, #96]	; (26d0 <test_Printf+0x94>)

  	gfx_SetFont(&sansBoldOblique18pt7b);
  	gfx_SetCursor(0, 0);
  	gfx_PutChar('\n');
  	gfx_SetTextColor(clWhite);
  	gfx_SetTextSize(1);
    2670:	2001      	movs	r0, #1
    2672:	f002 f89b 	bl	47ac <gfx_SetTextSize>
  	rprintf(STDIO_DEV3, "Ola mundo"CMD_TERMINATOR);
    2676:	4917      	ldr	r1, [pc, #92]	; (26d4 <test_Printf+0x98>)
    2678:	2006      	movs	r0, #6
    267a:	f000 fda3 	bl	31c4 <rprintf>
  	//gfx_printf("alex: %d  pi: %.2f 1234567890"CMD_TERMINATOR, 43, 3.1415);
  	//gfx_printf("12.3 ");

  	//gfx_SetFont(&serifBoldItalic24pt7b);
  	gfx_SetTextColor(clCyan);
  	gfx_printf("12.3 ");
    267e:	4d16      	ldr	r5, [pc, #88]	; (26d8 <test_Printf+0x9c>)
  	gfx_SetCursor(0, 0);
  	gfx_PutChar('\n');
  	gfx_SetTextColor(clWhite);
  	gfx_SetTextSize(1);
  	rprintf(STDIO_DEV3, "Ola mundo"CMD_TERMINATOR);
	gfx_printf(CMD_TERMINATOR);
    2680:	4620      	mov	r0, r4
    2682:	f002 f98b 	bl	499c <gfx_printf>
  	//gfx_SetTextColor(clPink);
  	//gfx_printf("alex: %d  pi: %.2f 1234567890"CMD_TERMINATOR, 43, 3.1415);
  	//gfx_printf("12.3 ");

  	//gfx_SetFont(&serifBoldItalic24pt7b);
  	gfx_SetTextColor(clCyan);
    2686:	f240 70ff 	movw	r0, #2047	; 0x7ff
    268a:	f002 f897 	bl	47bc <gfx_SetTextColor>
  	gfx_printf("12.3 ");
    268e:	4628      	mov	r0, r5
    2690:	f002 f984 	bl	499c <gfx_printf>

	gfx_SetFont(&sansOblique24pt7b);
    2694:	4811      	ldr	r0, [pc, #68]	; (26dc <test_Printf+0xa0>)
    2696:	f002 f971 	bl	497c <gfx_SetFont>
  	gfx_SetTextColor(clBlue);
    269a:	201f      	movs	r0, #31
    269c:	f002 f88e 	bl	47bc <gfx_SetTextColor>
  	gfx_printf("12.3 ");
    26a0:	4628      	mov	r0, r5
    26a2:	f002 f97b 	bl	499c <gfx_printf>
  	gfx_printf(CMD_TERMINATOR);
    26a6:	4620      	mov	r0, r4
    26a8:	f002 f978 	bl	499c <gfx_printf>

	gfx_SetFont(&tomThumb);
    26ac:	480c      	ldr	r0, [pc, #48]	; (26e0 <test_Printf+0xa4>)
    26ae:	f002 f965 	bl	497c <gfx_SetFont>
  	gfx_SetTextColor(clBlue);
    26b2:	201f      	movs	r0, #31
    26b4:	f002 f882 	bl	47bc <gfx_SetTextColor>
  	gfx_printf("12.3 ");
    26b8:	4628      	mov	r0, r5
    26ba:	f002 f96f 	bl	499c <gfx_printf>
  	gfx_printf(CMD_TERMINATOR);
    26be:	4620      	mov	r0, r4

	//	gfx_SetTextColor(clGreen);
	//	gfx_SetTextSize(2);
	// 	gfx_PutChar('O');
	// 	gfx_PutChar('K');
}
    26c0:	e8bd 4038 	ldmia.w	sp!, {r3, r4, r5, lr}
  	gfx_printf(CMD_TERMINATOR);

	gfx_SetFont(&tomThumb);
  	gfx_SetTextColor(clBlue);
  	gfx_printf("12.3 ");
  	gfx_printf(CMD_TERMINATOR);
    26c4:	f002 b96a 	b.w	499c <gfx_printf>
    26c8:	000048c1 	.word	0x000048c1
    26cc:	10000014 	.word	0x10000014
    26d0:	000059ed 	.word	0x000059ed
    26d4:	00005983 	.word	0x00005983
    26d8:	0000598e 	.word	0x0000598e
    26dc:	10000028 	.word	0x10000028
    26e0:	10000000 	.word	0x10000000

Disassembly of section .text.test_Text:

000026e4 <test_Text>:
  	}
}



void test_Text(void) {
    26e4:	b510      	push	{r4, lr}
	uint rotation;
	for(rotation=0; rotation<4; rotation++) {
    26e6:	2400      	movs	r4, #0
    	gfx_SetRotation(rotation);
    26e8:	b2e0      	uxtb	r0, r4
    26ea:	f001 fc5d 	bl	3fa8 <gfx_SetRotation>



void test_Text(void) {
	uint rotation;
	for(rotation=0; rotation<4; rotation++) {
    26ee:	3401      	adds	r4, #1
    	gfx_SetRotation(rotation);
    	test_Printf();
    26f0:	f7ff ffa4 	bl	263c <test_Printf>
    	delay_ms(3000);
    26f4:	4805      	ldr	r0, [pc, #20]	; (270c <test_Text+0x28>)
    26f6:	f7ff fa3d 	bl	1b74 <delay>



void test_Text(void) {
	uint rotation;
	for(rotation=0; rotation<4; rotation++) {
    26fa:	2c04      	cmp	r4, #4
    26fc:	d1f4      	bne.n	26e8 <test_Text+0x4>
    	gfx_SetRotation(rotation);
    	test_Printf();
    	delay_ms(3000);
  	}
  	gfx_SetRotation(0);
    26fe:	2000      	movs	r0, #0
    2700:	f001 fc52 	bl	3fa8 <gfx_SetRotation>
  	test_Printf();
}
    2704:	e8bd 4010 	ldmia.w	sp!, {r4, lr}
    	gfx_SetRotation(rotation);
    	test_Printf();
    	delay_ms(3000);
  	}
  	gfx_SetRotation(0);
  	test_Printf();
    2708:	f7ff bf98 	b.w	263c <test_Printf>
    270c:	05f767a0 	.word	0x05f767a0

Disassembly of section .text.onKeyDown:

00002710 <onKeyDown>:
}

// #######################################################################################################
// KEYBOARD
// #######################################################################################################
void onKeyDown(char key) {
    2710:	b510      	push	{r4, lr}
    2712:	4604      	mov	r4, r0
	lprintf("onKeyDown key [0x%x]"CMD_TERMINATOR, key);
    2714:	4602      	mov	r2, r0
    2716:	490a      	ldr	r1, [pc, #40]	; (2740 <onKeyDown+0x30>)
    2718:	2001      	movs	r0, #1
    271a:	f000 fd53 	bl	31c4 <rprintf>
	if (key == SW0) beep_Play(4);
    271e:	2c01      	cmp	r4, #1
    2720:	d101      	bne.n	2726 <onKeyDown+0x16>
    2722:	2004      	movs	r0, #4
    2724:	e006      	b.n	2734 <onKeyDown+0x24>
	else if (key == SW1) beep_Play(5);
    2726:	2c02      	cmp	r4, #2
    2728:	d101      	bne.n	272e <onKeyDown+0x1e>
    272a:	2005      	movs	r0, #5
    272c:	e002      	b.n	2734 <onKeyDown+0x24>
	else if (key == SW2) beep_Play(6);
    272e:	2c04      	cmp	r4, #4
    2730:	d104      	bne.n	273c <onKeyDown+0x2c>
    2732:	2006      	movs	r0, #6
}
    2734:	e8bd 4010 	ldmia.w	sp!, {r4, lr}
// #######################################################################################################
void onKeyDown(char key) {
	lprintf("onKeyDown key [0x%x]"CMD_TERMINATOR, key);
	if (key == SW0) beep_Play(4);
	else if (key == SW1) beep_Play(5);
	else if (key == SW2) beep_Play(6);
    2738:	f000 bf60 	b.w	35fc <beep_Play>
    273c:	bd10      	pop	{r4, pc}
    273e:	bf00      	nop
    2740:	00005994 	.word	0x00005994

Disassembly of section .text.onKeyPress:

00002744 <onKeyPress>:
}

void onKeyPress(char key __attribute__ ((unused)) ) {
	lprintf("onKeyPress key [0x%x] fastInc[%d] "CMD_TERMINATOR, key, gkey_FastInc);
    2744:	4b03      	ldr	r3, [pc, #12]	; (2754 <onKeyPress+0x10>)
    2746:	4602      	mov	r2, r0
    2748:	681b      	ldr	r3, [r3, #0]
    274a:	4903      	ldr	r1, [pc, #12]	; (2758 <onKeyPress+0x14>)
    274c:	2001      	movs	r0, #1
    274e:	f000 bd39 	b.w	31c4 <rprintf>
    2752:	bf00      	nop
    2754:	100005f4 	.word	0x100005f4
    2758:	000059aa 	.word	0x000059aa

Disassembly of section .text.onKeyUp:

0000275c <onKeyUp>:
}

void onKeyUp(char key __attribute__ ((unused)) ) {
	lprintf("onKeyUp key [0x%x] fastInc[%d] "CMD_TERMINATOR, key, gkey_FastInc);
    275c:	4b03      	ldr	r3, [pc, #12]	; (276c <onKeyUp+0x10>)
    275e:	4602      	mov	r2, r0
    2760:	681b      	ldr	r3, [r3, #0]
    2762:	4903      	ldr	r1, [pc, #12]	; (2770 <onKeyUp+0x14>)
    2764:	2001      	movs	r0, #1
    2766:	f000 bd2d 	b.w	31c4 <rprintf>
    276a:	bf00      	nop
    276c:	100005f4 	.word	0x100005f4
    2770:	000059ce 	.word	0x000059ce

Disassembly of section .text.relay_Init:

00002774 <relay_Init>:

// #######################################################################################################
// RELAYS
// #######################################################################################################
void relay_Init(void) {
	relay1_Init();
    2774:	4b07      	ldr	r3, [pc, #28]	; (2794 <relay_Init+0x20>)
    2776:	681a      	ldr	r2, [r3, #0]
    2778:	f042 4280 	orr.w	r2, r2, #1073741824	; 0x40000000
    277c:	601a      	str	r2, [r3, #0]
	relay2_Init();
    277e:	681a      	ldr	r2, [r3, #0]
    2780:	f042 4200 	orr.w	r2, r2, #2147483648	; 0x80000000
    2784:	601a      	str	r2, [r3, #0]

	control.relay1.st = 0;
    2786:	4b04      	ldr	r3, [pc, #16]	; (2798 <relay_Init+0x24>)
    2788:	2200      	movs	r2, #0
	control.relay1.timeout = 0;
    278a:	60da      	str	r2, [r3, #12]
// #######################################################################################################
void relay_Init(void) {
	relay1_Init();
	relay2_Init();

	control.relay1.st = 0;
    278c:	609a      	str	r2, [r3, #8]
	control.relay1.timeout = 0;

	control.relay2.st = 0;
    278e:	611a      	str	r2, [r3, #16]
	control.relay2.timeout = 0;
    2790:	615a      	str	r2, [r3, #20]
    2792:	4770      	bx	lr
    2794:	2009c020 	.word	0x2009c020
    2798:	100005dc 	.word	0x100005dc

Disassembly of section .text.relay_Set:

0000279c <relay_Set>:
//	parametro timeout: O tempo em segundos que o rele vai ficar no estado atual e voltar para o estado inverso
//		Se colocar valor 0, permanece no estado atual até o próximo comando
int relay_Set(int rly, int st, uint timeout) {
	pRelay rl;

	if ( (rly < 0) || (rly > 1) ) return errDEVICE_NOT_FOUND;
    279c:	2801      	cmp	r0, #1
// Liga ou desliga o rele
//	parametro rly: sinaliza qual o rele vamos acessar. valor 0 ou 1
//	parametro st: pdON liga o rele e pdOFF desliga o rele;
//	parametro timeout: O tempo em segundos que o rele vai ficar no estado atual e voltar para o estado inverso
//		Se colocar valor 0, permanece no estado atual até o próximo comando
int relay_Set(int rly, int st, uint timeout) {
    279e:	b510      	push	{r4, lr}
	pRelay rl;

	if ( (rly < 0) || (rly > 1) ) return errDEVICE_NOT_FOUND;
    27a0:	d80d      	bhi.n	27be <relay_Set+0x22>
	if (rly == 0) rl = &control.relay1; else rl = &control.relay2;
    27a2:	4b08      	ldr	r3, [pc, #32]	; (27c4 <relay_Set+0x28>)
    27a4:	f103 0408 	add.w	r4, r3, #8
    27a8:	2800      	cmp	r0, #0
    27aa:	bf0c      	ite	eq
    27ac:	4618      	moveq	r0, r3
    27ae:	4620      	movne	r0, r4

	rl->timeout = timeout*1000;
    27b0:	f44f 737a 	mov.w	r3, #1000	; 0x3e8
    27b4:	435a      	muls	r2, r3
	rl->st = st;
    27b6:	6001      	str	r1, [r0, #0]
	pRelay rl;

	if ( (rly < 0) || (rly > 1) ) return errDEVICE_NOT_FOUND;
	if (rly == 0) rl = &control.relay1; else rl = &control.relay2;

	rl->timeout = timeout*1000;
    27b8:	6042      	str	r2, [r0, #4]
	rl->st = st;

	return pdPASS;
    27ba:	2001      	movs	r0, #1
    27bc:	bd10      	pop	{r4, pc}
//	parametro timeout: O tempo em segundos que o rele vai ficar no estado atual e voltar para o estado inverso
//		Se colocar valor 0, permanece no estado atual até o próximo comando
int relay_Set(int rly, int st, uint timeout) {
	pRelay rl;

	if ( (rly < 0) || (rly > 1) ) return errDEVICE_NOT_FOUND;
    27be:	4802      	ldr	r0, [pc, #8]	; (27c8 <relay_Set+0x2c>)

	rl->timeout = timeout*1000;
	rl->st = st;

	return pdPASS;
}
    27c0:	bd10      	pop	{r4, pc}
    27c2:	bf00      	nop
    27c4:	100005e4 	.word	0x100005e4
    27c8:	fffffed4 	.word	0xfffffed4

Disassembly of section .text.relay_Tick:

000027cc <relay_Tick>:

void relay_Tick(void) {
	if (control.relay1.st) relay1_On(); else relay1_Off();
    27cc:	4b16      	ldr	r3, [pc, #88]	; (2828 <relay_Tick+0x5c>)
	rl->st = st;

	return pdPASS;
}

void relay_Tick(void) {
    27ce:	b510      	push	{r4, lr}
	if (control.relay1.st) relay1_On(); else relay1_Off();
    27d0:	6899      	ldr	r1, [r3, #8]
    27d2:	f04f 4280 	mov.w	r2, #1073741824	; 0x40000000
    27d6:	b109      	cbz	r1, 27dc <relay_Tick+0x10>
    27d8:	4814      	ldr	r0, [pc, #80]	; (282c <relay_Tick+0x60>)
    27da:	e000      	b.n	27de <relay_Tick+0x12>
    27dc:	4814      	ldr	r0, [pc, #80]	; (2830 <relay_Tick+0x64>)
    27de:	6002      	str	r2, [r0, #0]
	if (control.relay2.st) relay2_On(); else relay2_Off();
    27e0:	691a      	ldr	r2, [r3, #16]
    27e2:	f04f 4000 	mov.w	r0, #2147483648	; 0x80000000
    27e6:	b10a      	cbz	r2, 27ec <relay_Tick+0x20>
    27e8:	4c10      	ldr	r4, [pc, #64]	; (282c <relay_Tick+0x60>)
    27ea:	e000      	b.n	27ee <relay_Tick+0x22>
    27ec:	4c10      	ldr	r4, [pc, #64]	; (2830 <relay_Tick+0x64>)
    27ee:	6020      	str	r0, [r4, #0]
	if (control.relay1.timeout > 0) control.relay1.timeout--;
    27f0:	68d8      	ldr	r0, [r3, #12]
    27f2:	4c0d      	ldr	r4, [pc, #52]	; (2828 <relay_Tick+0x5c>)
    27f4:	b110      	cbz	r0, 27fc <relay_Tick+0x30>
    27f6:	68e0      	ldr	r0, [r4, #12]
    27f8:	3801      	subs	r0, #1
    27fa:	60e0      	str	r0, [r4, #12]
	if (control.relay2.timeout > 0) control.relay2.timeout--;
    27fc:	6958      	ldr	r0, [r3, #20]
    27fe:	4c0a      	ldr	r4, [pc, #40]	; (2828 <relay_Tick+0x5c>)
    2800:	b110      	cbz	r0, 2808 <relay_Tick+0x3c>
    2802:	6960      	ldr	r0, [r4, #20]
    2804:	3801      	subs	r0, #1
    2806:	6160      	str	r0, [r4, #20]
	//colocar depois do acionamento para que seja certinho a contagem dos tempos
	if (control.relay1.timeout == 1) control.relay1.st ^= 1;
    2808:	68d8      	ldr	r0, [r3, #12]
	if (control.relay2.timeout == 1) control.relay2.st ^= 1;
    280a:	695b      	ldr	r3, [r3, #20]
	if (control.relay1.st) relay1_On(); else relay1_Off();
	if (control.relay2.st) relay2_On(); else relay2_Off();
	if (control.relay1.timeout > 0) control.relay1.timeout--;
	if (control.relay2.timeout > 0) control.relay2.timeout--;
	//colocar depois do acionamento para que seja certinho a contagem dos tempos
	if (control.relay1.timeout == 1) control.relay1.st ^= 1;
    280c:	2801      	cmp	r0, #1
    280e:	bf02      	ittt	eq
    2810:	4805      	ldreq	r0, [pc, #20]	; (2828 <relay_Tick+0x5c>)
    2812:	f081 0101 	eoreq.w	r1, r1, #1
    2816:	6081      	streq	r1, [r0, #8]
	if (control.relay2.timeout == 1) control.relay2.st ^= 1;
    2818:	2b01      	cmp	r3, #1
    281a:	bf02      	ittt	eq
    281c:	4b02      	ldreq	r3, [pc, #8]	; (2828 <relay_Tick+0x5c>)
    281e:	f082 0201 	eoreq.w	r2, r2, #1
    2822:	611a      	streq	r2, [r3, #16]
    2824:	bd10      	pop	{r4, pc}
    2826:	bf00      	nop
    2828:	100005dc 	.word	0x100005dc
    282c:	2009c038 	.word	0x2009c038
    2830:	2009c03c 	.word	0x2009c03c

Disassembly of section .text.app_Init:

00002834 <app_Init>:
}

// #######################################################################################################
// APPLICATION
// #######################################################################################################
void app_Init(void) {
    2834:	b508      	push	{r3, lr}
	control.ticks = 0;
    2836:	4b0c      	ldr	r3, [pc, #48]	; (2868 <app_Init+0x34>)
    2838:	2200      	movs	r2, #0
    283a:	601a      	str	r2, [r3, #0]
	control.key = 0;
    283c:	711a      	strb	r2, [r3, #4]

	relay_Init();
    283e:	f7ff ff99 	bl	2774 <relay_Init>

	ledB_Init();
    2842:	4a0a      	ldr	r2, [pc, #40]	; (286c <app_Init+0x38>)
    2844:	6813      	ldr	r3, [r2, #0]
    2846:	f043 5380 	orr.w	r3, r3, #268435456	; 0x10000000
    284a:	6013      	str	r3, [r2, #0]

// #######################################################################################################
// TFT
// #######################################################################################################
void tft_BackLight(int st) {
	if (st) ledB_On(); else ledB_Off();
    284c:	4b08      	ldr	r3, [pc, #32]	; (2870 <app_Init+0x3c>)
    284e:	f04f 5280 	mov.w	r2, #268435456	; 0x10000000
    2852:	601a      	str	r2, [r3, #0]

	relay_Init();

	ledB_Init();
	tft_BackLight(pdON);
	tft_Init();
    2854:	f001 f8f8 	bl	3a48 <tft_Init>
	gfx_Init();
    2858:	f001 fb7a 	bl	3f50 <gfx_Init>
	gfx_printfInit(STDIO_DEV2);
}
    285c:	e8bd 4008 	ldmia.w	sp!, {r3, lr}

	ledB_Init();
	tft_BackLight(pdON);
	tft_Init();
	gfx_Init();
	gfx_printfInit(STDIO_DEV2);
    2860:	2005      	movs	r0, #5
    2862:	f002 b891 	b.w	4988 <gfx_printfInit>
    2866:	bf00      	nop
    2868:	100005dc 	.word	0x100005dc
    286c:	2009c020 	.word	0x2009c020
    2870:	2009c038 	.word	0x2009c038

Disassembly of section .text.app_Tick:

00002874 <app_Tick>:
}

// Aqui descre, ou chame, códigos que controlam tempos ou que sejam executados em tempos reguladores
void app_Tick(void) {
    2874:	b570      	push	{r4, r5, r6, lr}
	// ATENÇÃO:  tempo de execução de TODOS os TICKS dentro dessa função NÃO pode ser superior a 1ms
	ledError_Tick();
    2876:	f000 fdaf 	bl	33d8 <ledError_Tick>
	beep_Tick();
    287a:	f000 fed1 	bl	3620 <beep_Tick>
	gKey_Tick();
    287e:	f000 fe05 	bl	348c <gKey_Tick>
	relay_Tick();
    2882:	f7ff ffa3 	bl	27cc <relay_Tick>

	// LEITURA DO TECLADO a cada 3ms
	static volatile uint timeReadKey = 0;
	static int bufKey[3];
	static uint idx = 0;
	if (timeReadKey) timeReadKey--;
    2886:	4b1f      	ldr	r3, [pc, #124]	; (2904 <app_Tick+0x90>)
    2888:	681a      	ldr	r2, [r3, #0]
    288a:	b112      	cbz	r2, 2892 <app_Tick+0x1e>
    288c:	681a      	ldr	r2, [r3, #0]
    288e:	3a01      	subs	r2, #1
    2890:	601a      	str	r2, [r3, #0]
	if (timeReadKey == 0) {
    2892:	681b      	ldr	r3, [r3, #0]
    2894:	4c1c      	ldr	r4, [pc, #112]	; (2908 <app_Tick+0x94>)
    2896:	2b00      	cmp	r3, #0
    2898:	d12f      	bne.n	28fa <app_Tick+0x86>
		timeReadKey = 3;

		// fazer debounce no teclado
		bufKey[idx%3] = (sw0_PIN&sw0_NUMPIN)?SW0:0;
    289a:	481c      	ldr	r0, [pc, #112]	; (290c <app_Tick+0x98>)
	static volatile uint timeReadKey = 0;
	static int bufKey[3];
	static uint idx = 0;
	if (timeReadKey) timeReadKey--;
	if (timeReadKey == 0) {
		timeReadKey = 3;
    289c:	4a19      	ldr	r2, [pc, #100]	; (2904 <app_Tick+0x90>)

		// fazer debounce no teclado
		bufKey[idx%3] = (sw0_PIN&sw0_NUMPIN)?SW0:0;
    289e:	6801      	ldr	r1, [r0, #0]
	static volatile uint timeReadKey = 0;
	static int bufKey[3];
	static uint idx = 0;
	if (timeReadKey) timeReadKey--;
	if (timeReadKey == 0) {
		timeReadKey = 3;
    28a0:	2303      	movs	r3, #3
    28a2:	6013      	str	r3, [r2, #0]

		// fazer debounce no teclado
		bufKey[idx%3] = (sw0_PIN&sw0_NUMPIN)?SW0:0;
    28a4:	fbb1 f3f3 	udiv	r3, r1, r3
    28a8:	4d19      	ldr	r5, [pc, #100]	; (2910 <app_Tick+0x9c>)
    28aa:	eb03 0343 	add.w	r3, r3, r3, lsl #1
    28ae:	1aca      	subs	r2, r1, r3
    28b0:	682b      	ldr	r3, [r5, #0]
		bufKey[idx%3] |= (sw1_PIN&sw1_NUMPIN)?SW1:0;
    28b2:	682e      	ldr	r6, [r5, #0]
		bufKey[idx%3] |= (sw2_PIN&sw2_NUMPIN)?SW2:0;
    28b4:	682d      	ldr	r5, [r5, #0]
	if (timeReadKey == 0) {
		timeReadKey = 3;

		// fazer debounce no teclado
		bufKey[idx%3] = (sw0_PIN&sw0_NUMPIN)?SW0:0;
		bufKey[idx%3] |= (sw1_PIN&sw1_NUMPIN)?SW1:0;
    28b6:	f416 2f00 	tst.w	r6, #524288	; 0x80000
    28ba:	bf14      	ite	ne
    28bc:	2602      	movne	r6, #2
    28be:	2600      	moveq	r6, #0
	if (timeReadKey) timeReadKey--;
	if (timeReadKey == 0) {
		timeReadKey = 3;

		// fazer debounce no teclado
		bufKey[idx%3] = (sw0_PIN&sw0_NUMPIN)?SW0:0;
    28c0:	f3c3 4380 	ubfx	r3, r3, #18, #1
		bufKey[idx%3] |= (sw1_PIN&sw1_NUMPIN)?SW1:0;
		bufKey[idx%3] |= (sw2_PIN&sw2_NUMPIN)?SW2:0;
    28c4:	f415 1f80 	tst.w	r5, #1048576	; 0x100000
	if (timeReadKey == 0) {
		timeReadKey = 3;

		// fazer debounce no teclado
		bufKey[idx%3] = (sw0_PIN&sw0_NUMPIN)?SW0:0;
		bufKey[idx%3] |= (sw1_PIN&sw1_NUMPIN)?SW1:0;
    28c8:	ea43 0306 	orr.w	r3, r3, r6
		bufKey[idx%3] |= (sw2_PIN&sw2_NUMPIN)?SW2:0;
    28cc:	4d11      	ldr	r5, [pc, #68]	; (2914 <app_Tick+0xa0>)
    28ce:	bf14      	ite	ne
    28d0:	2604      	movne	r6, #4
    28d2:	2600      	moveq	r6, #0
    28d4:	4333      	orrs	r3, r6
    28d6:	f845 3022 	str.w	r3, [r5, r2, lsl #2]

		if ( (bufKey[0] == bufKey[1]) && (bufKey[1] == bufKey[2]) ) {
    28da:	682b      	ldr	r3, [r5, #0]
    28dc:	686a      	ldr	r2, [r5, #4]
    28de:	4293      	cmp	r3, r2
    28e0:	d105      	bne.n	28ee <app_Tick+0x7a>
    28e2:	68aa      	ldr	r2, [r5, #8]
    28e4:	4293      	cmp	r3, r2
			control.key = bufKey[2]&0x7; // para que não pegar o botão de reconfigure
    28e6:	bf04      	itt	eq
    28e8:	f003 0307 	andeq.w	r3, r3, #7
    28ec:	7123      	strbeq	r3, [r4, #4]
		}
		if (idx == 2) idx = 0; else idx++;
    28ee:	2902      	cmp	r1, #2
    28f0:	bf0b      	itete	eq
    28f2:	2300      	moveq	r3, #0
    28f4:	3101      	addne	r1, #1
    28f6:	6003      	streq	r3, [r0, #0]
    28f8:	6001      	strne	r1, [r0, #0]
	}

	control.ticks++; // Contador de ticks do sistema
    28fa:	6823      	ldr	r3, [r4, #0]
    28fc:	3301      	adds	r3, #1
    28fe:	6023      	str	r3, [r4, #0]
    2900:	bd70      	pop	{r4, r5, r6, pc}
    2902:	bf00      	nop
    2904:	10000760 	.word	0x10000760
    2908:	100005dc 	.word	0x100005dc
    290c:	10000770 	.word	0x10000770
    2910:	2009c034 	.word	0x2009c034
    2914:	10000764 	.word	0x10000764

Disassembly of section .text.app_Process:

00002918 <app_Process>:
}


// Aqui descre, ou chame, códigos que não controlam tempos ou que não sejam executados em tempo reguladores, pelo menos diretamente
void app_Process(void) {
    2918:	4770      	bx	lr

Disassembly of section .text.prompt_ClearTicks:

0000291c <prompt_ClearTicks>:

	return pdPASS;
}

static int prompt_ClearTicks(int argc __attribute__ ((unused)), portCHAR **argv __attribute__ ((unused))) {
	control.ticks = 0;
    291c:	4b02      	ldr	r3, [pc, #8]	; (2928 <prompt_ClearTicks+0xc>)
    291e:	2200      	movs	r2, #0
    2920:	601a      	str	r2, [r3, #0]
	return pdPASS;
}
    2922:	2001      	movs	r0, #1
    2924:	4770      	bx	lr
    2926:	bf00      	nop
    2928:	100005dc 	.word	0x100005dc

Disassembly of section .text.prompt_STS:

0000292c <prompt_STS>:
		break;
	}
	return pdPASS;
}

static int prompt_STS(int argc __attribute__ ((unused)), portCHAR **argv __attribute__ ((unused))) {
    292c:	b538      	push	{r3, r4, r5, lr}
	lprintf(CMD_TERMINATOR);
    292e:	4c13      	ldr	r4, [pc, #76]	; (297c <prompt_STS+0x50>)
    2930:	2001      	movs	r0, #1
    2932:	4621      	mov	r1, r4
    2934:	f000 fc46 	bl	31c4 <rprintf>
	lprintf(CMD_TERMINATOR);
    2938:	4621      	mov	r1, r4
    293a:	2001      	movs	r0, #1
    293c:	f000 fc42 	bl	31c4 <rprintf>
	lprintf("SYSTEM"CMD_TERMINATOR);
    2940:	490f      	ldr	r1, [pc, #60]	; (2980 <prompt_STS+0x54>)
    2942:	2001      	movs	r0, #1
    2944:	f000 fc3e 	bl	31c4 <rprintf>
	lprintf("    "PROGAM_NAME);
	lprintf("    ucLibc version "__VERSION CMD_TERMINATOR);
	lprintf("    count TICKS: %u"CMD_TERMINATOR, control.ticks);
    2948:	4d0e      	ldr	r5, [pc, #56]	; (2984 <prompt_STS+0x58>)

static int prompt_STS(int argc __attribute__ ((unused)), portCHAR **argv __attribute__ ((unused))) {
	lprintf(CMD_TERMINATOR);
	lprintf(CMD_TERMINATOR);
	lprintf("SYSTEM"CMD_TERMINATOR);
	lprintf("    "PROGAM_NAME);
    294a:	490f      	ldr	r1, [pc, #60]	; (2988 <prompt_STS+0x5c>)
    294c:	2001      	movs	r0, #1
    294e:	f000 fc39 	bl	31c4 <rprintf>
	lprintf("    ucLibc version "__VERSION CMD_TERMINATOR);
    2952:	490e      	ldr	r1, [pc, #56]	; (298c <prompt_STS+0x60>)
    2954:	2001      	movs	r0, #1
    2956:	f000 fc35 	bl	31c4 <rprintf>
	lprintf("    count TICKS: %u"CMD_TERMINATOR, control.ticks);
    295a:	682a      	ldr	r2, [r5, #0]
    295c:	490c      	ldr	r1, [pc, #48]	; (2990 <prompt_STS+0x64>)
    295e:	2001      	movs	r0, #1
    2960:	f000 fc30 	bl	31c4 <rprintf>
	lprintf("    key pressing: %u"CMD_TERMINATOR, control.key);
    2964:	792a      	ldrb	r2, [r5, #4]
    2966:	490b      	ldr	r1, [pc, #44]	; (2994 <prompt_STS+0x68>)
    2968:	2001      	movs	r0, #1
    296a:	f000 fc2b 	bl	31c4 <rprintf>
	lprintf(CMD_TERMINATOR);
    296e:	4621      	mov	r1, r4
    2970:	2001      	movs	r0, #1
    2972:	f000 fc27 	bl	31c4 <rprintf>

	return pdPASS;
}
    2976:	2001      	movs	r0, #1
    2978:	bd38      	pop	{r3, r4, r5, pc}
    297a:	bf00      	nop
    297c:	000059ed 	.word	0x000059ed
    2980:	0000a3a0 	.word	0x0000a3a0
    2984:	100005dc 	.word	0x100005dc
    2988:	0000a3a8 	.word	0x0000a3a8
    298c:	0000a3ec 	.word	0x0000a3ec
    2990:	0000a404 	.word	0x0000a404
    2994:	0000a419 	.word	0x0000a419

Disassembly of section .text.prompt_Tests:

00002998 <prompt_Tests>:
static int prompt_Init(int argc __attribute__ ((unused)), portCHAR **argv __attribute__ ((unused))) {
	tft_Init();
	return pdPASS;
}

static int prompt_Tests(int argc __attribute__ ((unused)), portCHAR **argv) {
    2998:	b507      	push	{r0, r1, r2, lr}
    299a:	4608      	mov	r0, r1
	long p1;
	if (!xatoi(&argv[0], &p1)) return pdFAIL;
    299c:	a901      	add	r1, sp, #4
    299e:	f000 fcbb 	bl	3318 <xatoi>
    29a2:	2800      	cmp	r0, #0
    29a4:	d047      	beq.n	2a36 <prompt_Tests+0x9e>
	switch(p1) {
    29a6:	9b01      	ldr	r3, [sp, #4]
    29a8:	3b01      	subs	r3, #1
    29aa:	2b0c      	cmp	r3, #12
    29ac:	d840      	bhi.n	2a30 <prompt_Tests+0x98>
    29ae:	e8df f003 	tbb	[pc, r3]
    29b2:	0a07      	.short	0x0a07
    29b4:	1f1c1610 	.word	0x1f1c1610
    29b8:	2f2a2522 	.word	0x2f2a2522
    29bc:	3936      	.short	0x3936
    29be:	3c          	.byte	0x3c
    29bf:	00          	.byte	0x00
	case 1: test_FillScreen(); break;
    29c0:	f7ff fb7c 	bl	20bc <test_FillScreen>
    29c4:	e036      	b.n	2a34 <prompt_Tests+0x9c>
	case 2: test_Circles(10, clWhite); break;
    29c6:	f64f 71ff 	movw	r1, #65535	; 0xffff
    29ca:	200a      	movs	r0, #10
    29cc:	f7ff fc58 	bl	2280 <test_Circles>
    29d0:	e030      	b.n	2a34 <prompt_Tests+0x9c>
	case 3: test_FastLines(clRed, clBlue); break;
    29d2:	211f      	movs	r1, #31
    29d4:	f44f 4078 	mov.w	r0, #63488	; 0xf800
    29d8:	f7ff fb96 	bl	2108 <test_FastLines>
    29dc:	e02a      	b.n	2a34 <prompt_Tests+0x9c>
	case 4: test_FilledCircles(10, clWhite); break;
    29de:	f64f 71ff 	movw	r1, #65535	; 0xffff
    29e2:	200a      	movs	r0, #10
    29e4:	f7ff fc6b 	bl	22be <test_FilledCircles>
    29e8:	e024      	b.n	2a34 <prompt_Tests+0x9c>
	case 5: test_Triangles(); break;
    29ea:	f7ff fc88 	bl	22fe <test_Triangles>
    29ee:	e021      	b.n	2a34 <prompt_Tests+0x9c>
	case 6: test_RoundRects(); break;
    29f0:	f7ff fcf8 	bl	23e4 <test_RoundRects>
    29f4:	e01e      	b.n	2a34 <prompt_Tests+0x9c>
	case 7: test_FilledRoundRects(); break;
    29f6:	f7ff fd2b 	bl	2450 <test_FilledRoundRects>
    29fa:	e01b      	b.n	2a34 <prompt_Tests+0x9c>
	case 8: test_Lines(clCyan); break;
    29fc:	f240 70ff 	movw	r0, #2047	; 0x7ff
    2a00:	f7ff fbaa 	bl	2158 <test_Lines>
    2a04:	e016      	b.n	2a34 <prompt_Tests+0x9c>
	case 9: test_Rects(clGreen); break;
    2a06:	f44f 60fc 	mov.w	r0, #2016	; 0x7e0
    2a0a:	f7ff fd56 	bl	24ba <test_Rects>
    2a0e:	e011      	b.n	2a34 <prompt_Tests+0x9c>
	case 10: test_FilledRects(clYellow, clMagneta); break;
    2a10:	f64f 011f 	movw	r1, #63519	; 0xf81f
    2a14:	f64f 70e0 	movw	r0, #65504	; 0xffe0
    2a18:	f7ff fd7b 	bl	2512 <test_FilledRects>
    2a1c:	e00a      	b.n	2a34 <prompt_Tests+0x9c>
	case 11: test_Text(); break;
    2a1e:	f7ff fe61 	bl	26e4 <test_Text>
    2a22:	e007      	b.n	2a34 <prompt_Tests+0x9c>
	case 12: test_Printf(); break;
    2a24:	f7ff fe0a 	bl	263c <test_Printf>
    2a28:	e004      	b.n	2a34 <prompt_Tests+0x9c>
	case 13: test_Buttons(); break;
    2a2a:	f7ff fdab 	bl	2584 <test_Buttons>
    2a2e:	e001      	b.n	2a34 <prompt_Tests+0x9c>

	default:
		test_FilledTriangles();
    2a30:	f7ff fc90 	bl	2354 <test_FilledTriangles>
		break;
	}
	return pdPASS;
    2a34:	2001      	movs	r0, #1
}
    2a36:	b003      	add	sp, #12
    2a38:	f85d fb04 	ldr.w	pc, [sp], #4

Disassembly of section .text.prompt_Init:

00002a3c <prompt_Init>:
static int prompt_Reset(int argc __attribute__ ((unused)), portCHAR **argv __attribute__ ((unused))) {
	tft_Reset();
	return pdPASS;
}

static int prompt_Init(int argc __attribute__ ((unused)), portCHAR **argv __attribute__ ((unused))) {
    2a3c:	b508      	push	{r3, lr}
	tft_Init();
    2a3e:	f001 f803 	bl	3a48 <tft_Init>
	return pdPASS;
}
    2a42:	2001      	movs	r0, #1
    2a44:	bd08      	pop	{r3, pc}

Disassembly of section .text.prompt_Reset:

00002a46 <prompt_Reset>:
	if (strcmp(argv[0], "on") == 0) p1=pdON; else p1=pdOFF;
	tft_BackLight(p1);
	return pdPASS;
}

static int prompt_Reset(int argc __attribute__ ((unused)), portCHAR **argv __attribute__ ((unused))) {
    2a46:	b508      	push	{r3, lr}
	tft_Reset();
    2a48:	f000 ffbe 	bl	39c8 <tft_Reset>
	return pdPASS;
}
    2a4c:	2001      	movs	r0, #1
    2a4e:	bd08      	pop	{r3, pc}

Disassembly of section .text.prompt_LedB:

00002a50 <prompt_LedB>:
  	}

	return pdPASS;
}

static int prompt_LedB(int argc __attribute__ ((unused)), portCHAR **argv) {
    2a50:	b508      	push	{r3, lr}
    2a52:	460b      	mov	r3, r1
	long p1;
	if (strcmp(argv[0], "on") == 0) p1=pdON; else p1=pdOFF;
    2a54:	4905      	ldr	r1, [pc, #20]	; (2a6c <prompt_LedB+0x1c>)
    2a56:	6818      	ldr	r0, [r3, #0]
    2a58:	f7fe fb28 	bl	10ac <strcmp>
	tft_BackLight(p1);
    2a5c:	fab0 f080 	clz	r0, r0
    2a60:	0940      	lsrs	r0, r0, #5
    2a62:	f7ff fb1f 	bl	20a4 <tft_BackLight>
	return pdPASS;
}
    2a66:	2001      	movs	r0, #1
    2a68:	bd08      	pop	{r3, pc}
    2a6a:	bf00      	nop
    2a6c:	00004c9a 	.word	0x00004c9a

Disassembly of section .text.prompt_Dump:

00002a70 <prompt_Dump>:
static int prompt_ClearTicks(int argc __attribute__ ((unused)), portCHAR **argv __attribute__ ((unused))) {
	control.ticks = 0;
	return pdPASS;
}

static int prompt_Dump (int argc __attribute__ ((unused)), portCHAR **argv ) {
    2a70:	b5f7      	push	{r0, r1, r2, r4, r5, r6, r7, lr}
    2a72:	460c      	mov	r4, r1
	long p1, p2;

	if (!xatoi(&argv[0], &p1)) return pdFAIL;
    2a74:	4669      	mov	r1, sp
    2a76:	4620      	mov	r0, r4
    2a78:	f000 fc4e 	bl	3318 <xatoi>
    2a7c:	b908      	cbnz	r0, 2a82 <prompt_Dump+0x12>
    2a7e:	2000      	movs	r0, #0
    2a80:	e039      	b.n	2af6 <prompt_Dump+0x86>
	if (!xatoi(&argv[1], &p2)) return pdFAIL;
    2a82:	a901      	add	r1, sp, #4
    2a84:	1d20      	adds	r0, r4, #4
    2a86:	f000 fc47 	bl	3318 <xatoi>
    2a8a:	2800      	cmp	r0, #0
    2a8c:	d0f7      	beq.n	2a7e <prompt_Dump+0xe>

	if (p1 < 0) p1 = 0;
    2a8e:	9b00      	ldr	r3, [sp, #0]
    2a90:	2b00      	cmp	r3, #0
    2a92:	bfbc      	itt	lt
    2a94:	2300      	movlt	r3, #0
    2a96:	9300      	strlt	r3, [sp, #0]
	if (p2 < 1) p2 = 256;
    2a98:	9b01      	ldr	r3, [sp, #4]

	u8 *ptr = (u8*) p1;
    2a9a:	9d00      	ldr	r5, [sp, #0]

	if (!xatoi(&argv[0], &p1)) return pdFAIL;
	if (!xatoi(&argv[1], &p2)) return pdFAIL;

	if (p1 < 0) p1 = 0;
	if (p2 < 1) p2 = 256;
    2a9c:	2b00      	cmp	r3, #0
    2a9e:	bfdc      	itt	le
    2aa0:	f44f 7380 	movle.w	r3, #256	; 0x100
    2aa4:	9301      	strle	r3, [sp, #4]

	u8 *ptr = (u8*) p1;
	u16 qtd_rd = p2;
    2aa6:	f8bd 4004 	ldrh.w	r4, [sp, #4]

	while (qtd_rd) {
    2aaa:	b31c      	cbz	r4, 2af4 <prompt_Dump+0x84>
  		if (qtd_rd >= 16)
    2aac:	2c0f      	cmp	r4, #15
    2aae:	d91a      	bls.n	2ae6 <prompt_Dump+0x76>
    2ab0:	462e      	mov	r6, r5
    2ab2:	192f      	adds	r7, r5, r4
    2ab4:	b2bf      	uxth	r7, r7
  			// Enquanto o qtd_rd for maior que 15 faz, depois incrementea addr do buffer e da eeprom por 16, e decrementa qtd_rd por 16
  			for( ; qtd_rd>=16; ptr+=16, p1+=16, qtd_rd-=16 )
  				put_dump16(ptr, p1, 16, 16);
    2ab6:	2310      	movs	r3, #16
    2ab8:	461a      	mov	r2, r3
    2aba:	4630      	mov	r0, r6
    2abc:	9900      	ldr	r1, [sp, #0]
    2abe:	f000 fbe1 	bl	3284 <put_dump16>
	u16 qtd_rd = p2;

	while (qtd_rd) {
  		if (qtd_rd >= 16)
  			// Enquanto o qtd_rd for maior que 15 faz, depois incrementea addr do buffer e da eeprom por 16, e decrementa qtd_rd por 16
  			for( ; qtd_rd>=16; ptr+=16, p1+=16, qtd_rd-=16 )
    2ac2:	9b00      	ldr	r3, [sp, #0]
    2ac4:	3610      	adds	r6, #16
    2ac6:	3310      	adds	r3, #16
    2ac8:	9300      	str	r3, [sp, #0]
    2aca:	1bbb      	subs	r3, r7, r6
    2acc:	b29b      	uxth	r3, r3
    2ace:	2b0f      	cmp	r3, #15
    2ad0:	d8f1      	bhi.n	2ab6 <prompt_Dump+0x46>
    2ad2:	f1a4 0310 	sub.w	r3, r4, #16
    2ad6:	f3c3 130b 	ubfx	r3, r3, #4, #12
    2ada:	3301      	adds	r3, #1
  				put_dump16(ptr, p1, 16, 16);

		if (qtd_rd)
    2adc:	f014 040f 	ands.w	r4, r4, #15
    2ae0:	eb05 1503 	add.w	r5, r5, r3, lsl #4
    2ae4:	d006      	beq.n	2af4 <prompt_Dump+0x84>
			put_dump16(ptr, p1, qtd_rd, 16);
    2ae6:	2310      	movs	r3, #16
    2ae8:	4622      	mov	r2, r4
    2aea:	9900      	ldr	r1, [sp, #0]
    2aec:	4628      	mov	r0, r5
    2aee:	f000 fbc9 	bl	3284 <put_dump16>
    2af2:	e7da      	b.n	2aaa <prompt_Dump+0x3a>
  	}

	return pdPASS;
    2af4:	2001      	movs	r0, #1
}
    2af6:	b003      	add	sp, #12
    2af8:	bdf0      	pop	{r4, r5, r6, r7, pc}

Disassembly of section .text.prompt_Beep:

00002afa <prompt_Beep>:
  	} else result_prompt = pdPASS;

	return result_prompt;
}

static int prompt_Beep(int argc __attribute__ ((unused)), portCHAR **argv) {
    2afa:	b507      	push	{r0, r1, r2, lr}
    2afc:	4608      	mov	r0, r1
	long p1;
	if (!xatoi(&argv[0], &p1)) return pdFAIL;
    2afe:	a901      	add	r1, sp, #4
    2b00:	f000 fc0a 	bl	3318 <xatoi>
    2b04:	b118      	cbz	r0, 2b0e <prompt_Beep+0x14>
	beep_Play(p1);
    2b06:	9801      	ldr	r0, [sp, #4]
    2b08:	f000 fd78 	bl	35fc <beep_Play>
	return pdPASS;
    2b0c:	2001      	movs	r0, #1
}
    2b0e:	b003      	add	sp, #12
    2b10:	f85d fb04 	ldr.w	pc, [sp], #4

Disassembly of section .text.prompt_Relay:

00002b14 <prompt_Relay>:

static int prompt_Relay(int argc __attribute__ ((unused)), portCHAR **argv ) {
    2b14:	b573      	push	{r0, r1, r4, r5, r6, lr}
    2b16:	460c      	mov	r4, r1
	long p1=0, p2=0, p3=0;
    2b18:	2300      	movs	r3, #0
	if (!xatoi(&argv[0], &p1)) return pdFAIL;
	beep_Play(p1);
	return pdPASS;
}

static int prompt_Relay(int argc __attribute__ ((unused)), portCHAR **argv ) {
    2b1a:	4606      	mov	r6, r0
	long p1=0, p2=0, p3=0;

	if (!xatoi(&argv[0], &p1)) return pdFAIL;
    2b1c:	4669      	mov	r1, sp
    2b1e:	4620      	mov	r0, r4
	beep_Play(p1);
	return pdPASS;
}

static int prompt_Relay(int argc __attribute__ ((unused)), portCHAR **argv ) {
	long p1=0, p2=0, p3=0;
    2b20:	9300      	str	r3, [sp, #0]
    2b22:	9301      	str	r3, [sp, #4]

	if (!xatoi(&argv[0], &p1)) return pdFAIL;
    2b24:	f000 fbf8 	bl	3318 <xatoi>
    2b28:	b908      	cbnz	r0, 2b2e <prompt_Relay+0x1a>
    2b2a:	2000      	movs	r0, #0
    2b2c:	e020      	b.n	2b70 <prompt_Relay+0x5c>
	if (strcmp(argv[1], "on") == 0) p2=pdON; else p2=pdOFF;
    2b2e:	4911      	ldr	r1, [pc, #68]	; (2b74 <prompt_Relay+0x60>)
    2b30:	6860      	ldr	r0, [r4, #4]
    2b32:	f7fe fabb 	bl	10ac <strcmp>
    2b36:	fab0 f580 	clz	r5, r0
	if (argc > 2) { if (!xatoi(&argv[2], &p3)) return pdFAIL; }
    2b3a:	2e02      	cmp	r6, #2

static int prompt_Relay(int argc __attribute__ ((unused)), portCHAR **argv ) {
	long p1=0, p2=0, p3=0;

	if (!xatoi(&argv[0], &p1)) return pdFAIL;
	if (strcmp(argv[1], "on") == 0) p2=pdON; else p2=pdOFF;
    2b3c:	ea4f 1555 	mov.w	r5, r5, lsr #5
	if (argc > 2) { if (!xatoi(&argv[2], &p3)) return pdFAIL; }
    2b40:	dc0d      	bgt.n	2b5e <prompt_Relay+0x4a>

	int ret = relay_Set(p1-1, p2, p3);
    2b42:	9800      	ldr	r0, [sp, #0]
    2b44:	9a01      	ldr	r2, [sp, #4]
    2b46:	4629      	mov	r1, r5
    2b48:	3801      	subs	r0, #1
    2b4a:	f7ff fe27 	bl	279c <relay_Set>

	if (ret == errDEVICE_NOT_FOUND)
    2b4e:	f510 7f96 	cmn.w	r0, #300	; 0x12c
    2b52:	d10c      	bne.n	2b6e <prompt_Relay+0x5a>
		lprintf("ERROR: relay must be 1 or 2"CMD_TERMINATOR);
    2b54:	4908      	ldr	r1, [pc, #32]	; (2b78 <prompt_Relay+0x64>)
    2b56:	2001      	movs	r0, #1
    2b58:	f000 fb34 	bl	31c4 <rprintf>
    2b5c:	e007      	b.n	2b6e <prompt_Relay+0x5a>
static int prompt_Relay(int argc __attribute__ ((unused)), portCHAR **argv ) {
	long p1=0, p2=0, p3=0;

	if (!xatoi(&argv[0], &p1)) return pdFAIL;
	if (strcmp(argv[1], "on") == 0) p2=pdON; else p2=pdOFF;
	if (argc > 2) { if (!xatoi(&argv[2], &p3)) return pdFAIL; }
    2b5e:	a901      	add	r1, sp, #4
    2b60:	f104 0008 	add.w	r0, r4, #8
    2b64:	f000 fbd8 	bl	3318 <xatoi>
    2b68:	2800      	cmp	r0, #0
    2b6a:	d1ea      	bne.n	2b42 <prompt_Relay+0x2e>
    2b6c:	e7dd      	b.n	2b2a <prompt_Relay+0x16>

	int ret = relay_Set(p1-1, p2, p3);

	if (ret == errDEVICE_NOT_FOUND)
		lprintf("ERROR: relay must be 1 or 2"CMD_TERMINATOR);
    2b6e:	2001      	movs	r0, #1

	return pdPASS;
}
    2b70:	b002      	add	sp, #8
    2b72:	bd70      	pop	{r4, r5, r6, pc}
    2b74:	00004c9a 	.word	0x00004c9a
    2b78:	0000a42f 	.word	0x0000a42f

Disassembly of section .text.prompt_Process:

00002b7c <prompt_Process>:
	{ NULL, 0,  0, CMD_TYPE_FUNCTION,  	{ NULL },
			NULL,
			NULL },
};

void prompt_Process(void) {
    2b7c:	b570      	push	{r4, r5, r6, lr}
static portCHAR *argv_prompt [CLI_N_ARGS];
static int argc_prompt;

static int prompt_ProcessCommand(void) {
	// CAPTURA COMANDOS DO TERMINAL. SE TECLOU ENTER A FUNÇÃO RETORNA COM A QUANTIDADE DE CHAR DO COMANDO
	result_prompt = cli_GetLine (buffer_prompt, sizeof (buffer_prompt), PROMPT); // Chamo o console para entrada de comandos
    2b7e:	4a18      	ldr	r2, [pc, #96]	; (2be0 <prompt_Process+0x64>)
    2b80:	2128      	movs	r1, #40	; 0x28
    2b82:	4818      	ldr	r0, [pc, #96]	; (2be4 <prompt_Process+0x68>)
    2b84:	f000 fd92 	bl	36ac <cli_GetLine>
    2b88:	4c17      	ldr	r4, [pc, #92]	; (2be8 <prompt_Process+0x6c>)
    2b8a:	6020      	str	r0, [r4, #0]

	// CHECA FOI ENTRADO COM O COMANDO
	if (result_prompt) {	// checa se há entrada de comandos
    2b8c:	b198      	cbz	r0, 2bb6 <prompt_Process+0x3a>
   		if (cli_ArgsParse ((char *) buffer_prompt, argv_prompt, sizeof (argv_prompt), &argc_prompt) == errCLI_EXED_ARGS) // Captura os endereços iniciais de cada argumento, contidos no comando, e grava nas posições do argv
    2b8e:	4e17      	ldr	r6, [pc, #92]	; (2bec <prompt_Process+0x70>)
    2b90:	4d17      	ldr	r5, [pc, #92]	; (2bf0 <prompt_Process+0x74>)
    2b92:	4633      	mov	r3, r6
    2b94:	2228      	movs	r2, #40	; 0x28
    2b96:	4629      	mov	r1, r5
    2b98:	4812      	ldr	r0, [pc, #72]	; (2be4 <prompt_Process+0x68>)
    2b9a:	f000 fe4d 	bl	3838 <cli_ArgsParse>
    2b9e:	f110 0f3c 	cmn.w	r0, #60	; 0x3c
    2ba2:	d006      	beq.n	2bb2 <prompt_Process+0x36>
   			result_prompt = errCLI_EXED_ARGS;
   		else if (argv_prompt[0])
    2ba4:	682b      	ldr	r3, [r5, #0]
    2ba6:	b143      	cbz	r3, 2bba <prompt_Process+0x3e>
   			result_prompt = cli_ArgsDispatch(cli_list, argc_prompt, &argv_prompt[0]);							// Executa a função referente ao comando digitado
    2ba8:	462a      	mov	r2, r5
    2baa:	6831      	ldr	r1, [r6, #0]
    2bac:	4811      	ldr	r0, [pc, #68]	; (2bf4 <prompt_Process+0x78>)
    2bae:	f000 febb 	bl	3928 <cli_ArgsDispatch>
    2bb2:	6020      	str	r0, [r4, #0]
    2bb4:	e001      	b.n	2bba <prompt_Process+0x3e>
  	} else result_prompt = pdPASS;
    2bb6:	2301      	movs	r3, #1
    2bb8:	6023      	str	r3, [r4, #0]
};

void prompt_Process(void) {
	static int resuslt;
	resuslt = prompt_ProcessCommand();
	switch (resuslt) {
    2bba:	6823      	ldr	r3, [r4, #0]
    2bbc:	f113 0f3c 	cmn.w	r3, #60	; 0x3c
    2bc0:	d004      	beq.n	2bcc <prompt_Process+0x50>
    2bc2:	b12b      	cbz	r3, 2bd0 <prompt_Process+0x54>
    2bc4:	333f      	adds	r3, #63	; 0x3f
    2bc6:	d109      	bne.n	2bdc <prompt_Process+0x60>
	case errCLI_EXED_ARGS:
		lprintf("System error"CMD_TERMINATOR);
		break;
	case errCLI_CMD_NOT_FOUND:
		lprintf("Unknown command"CMD_TERMINATOR);
    2bc8:	490b      	ldr	r1, [pc, #44]	; (2bf8 <prompt_Process+0x7c>)
    2bca:	e002      	b.n	2bd2 <prompt_Process+0x56>
void prompt_Process(void) {
	static int resuslt;
	resuslt = prompt_ProcessCommand();
	switch (resuslt) {
	case errCLI_EXED_ARGS:
		lprintf("System error"CMD_TERMINATOR);
    2bcc:	490b      	ldr	r1, [pc, #44]	; (2bfc <prompt_Process+0x80>)
    2bce:	e000      	b.n	2bd2 <prompt_Process+0x56>
		break;
	case errCLI_CMD_NOT_FOUND:
		lprintf("Unknown command"CMD_TERMINATOR);
    	break;
    case pdFAIL:
    	lprintf("Error in executing the command"CMD_TERMINATOR);
    2bd0:	490b      	ldr	r1, [pc, #44]	; (2c00 <prompt_Process+0x84>)
    2bd2:	2001      	movs	r0, #1
    	break;
    }
}
    2bd4:	e8bd 4070 	ldmia.w	sp!, {r4, r5, r6, lr}
		break;
	case errCLI_CMD_NOT_FOUND:
		lprintf("Unknown command"CMD_TERMINATOR);
    	break;
    case pdFAIL:
    	lprintf("Error in executing the command"CMD_TERMINATOR);
    2bd8:	f000 baf4 	b.w	31c4 <rprintf>
    2bdc:	bd70      	pop	{r4, r5, r6, pc}
    2bde:	bf00      	nop
    2be0:	0000a44c 	.word	0x0000a44c
    2be4:	100007a4 	.word	0x100007a4
    2be8:	10000778 	.word	0x10000778
    2bec:	10000774 	.word	0x10000774
    2bf0:	1000077c 	.word	0x1000077c
    2bf4:	0000a2c4 	.word	0x0000a2c4
    2bf8:	0000a45e 	.word	0x0000a45e
    2bfc:	0000a450 	.word	0x0000a450
    2c00:	0000a46f 	.word	0x0000a46f

Disassembly of section .text.print_putchar:

00002c04 <print_putchar>:
// IMPRESSÃO DE CARACTERES
// #######################################################################################################################

//  Esta função direciona a impressão do caractere para o dipositivo de saida ou armazena em buffer de formatação de string
static void print_putchar(pPrint output, u8 c) {
	if (output->buf!=NULL) { 				// Checa se há buffer para fazer formatação de string
    2c04:	6802      	ldr	r2, [r0, #0]
// #######################################################################################################################
// IMPRESSÃO DE CARACTERES
// #######################################################################################################################

//  Esta função direciona a impressão do caractere para o dipositivo de saida ou armazena em buffer de formatação de string
static void print_putchar(pPrint output, u8 c) {
    2c06:	b538      	push	{r3, r4, r5, lr}
	if (output->buf!=NULL) { 				// Checa se há buffer para fazer formatação de string
    2c08:	b122      	cbz	r2, 2c14 <print_putchar+0x10>
		output->buf[output->count++] = c;
    2c0a:	6843      	ldr	r3, [r0, #4]
    2c0c:	1c5c      	adds	r4, r3, #1
    2c0e:	6044      	str	r4, [r0, #4]
    2c10:	54d1      	strb	r1, [r2, r3]
		return;		// se é somente para fazer formatação de string não vamos fazer impressão em dispositivo
    2c12:	bd38      	pop	{r3, r4, r5, pc}
	#if defined(LINUX)
	stdio_putc(c);
	#else
	static int (*putcharfunc)(n16 c);
	
	switch(output->device) {
    2c14:	7b03      	ldrb	r3, [r0, #12]
    2c16:	4c10      	ldr	r4, [pc, #64]	; (2c58 <print_putchar+0x54>)
    2c18:	3b01      	subs	r3, #1
    2c1a:	2b06      	cmp	r3, #6
    2c1c:	d814      	bhi.n	2c48 <print_putchar+0x44>
    2c1e:	e8df f003 	tbb	[pc, r3]
    2c22:	0604      	.short	0x0604
    2c24:	0e0c0a08 	.word	0x0e0c0a08
    2c28:	10          	.byte	0x10
    2c29:	00          	.byte	0x00
		case STDIO_LPRINTF:	putcharfunc = stdio_putc; break;
    2c2a:	4b0c      	ldr	r3, [pc, #48]	; (2c5c <print_putchar+0x58>)
    2c2c:	e00a      	b.n	2c44 <print_putchar+0x40>
		case STDIO_DEBUG:	putcharfunc = debug_putc; break;
    2c2e:	4b0c      	ldr	r3, [pc, #48]	; (2c60 <print_putchar+0x5c>)
    2c30:	e008      	b.n	2c44 <print_putchar+0x40>
		case STDIO_ERROR:	putcharfunc = err_putc; break;
    2c32:	4b0c      	ldr	r3, [pc, #48]	; (2c64 <print_putchar+0x60>)
    2c34:	e006      	b.n	2c44 <print_putchar+0x40>
		case STDIO_DEV1: 	putcharfunc = dev1_putc; break;
    2c36:	4b0c      	ldr	r3, [pc, #48]	; (2c68 <print_putchar+0x64>)
    2c38:	e004      	b.n	2c44 <print_putchar+0x40>
   		case STDIO_DEV2: 	putcharfunc = dev2_putc; break;
    2c3a:	4b0c      	ldr	r3, [pc, #48]	; (2c6c <print_putchar+0x68>)
    2c3c:	e002      	b.n	2c44 <print_putchar+0x40>
   		case STDIO_DEV3: 	putcharfunc = dev3_putc; break;
    2c3e:	4b0c      	ldr	r3, [pc, #48]	; (2c70 <print_putchar+0x6c>)
    2c40:	e000      	b.n	2c44 <print_putchar+0x40>
   		case STDIO_DEV4: 	putcharfunc = dev4_putc; break;
    2c42:	4b0c      	ldr	r3, [pc, #48]	; (2c74 <print_putchar+0x70>)
    2c44:	681b      	ldr	r3, [r3, #0]
    2c46:	6023      	str	r3, [r4, #0]
  	}

	// senão joga na porta de saida
	// Espera até que consiga incluir o caractere no buffer de TX
	while (putcharfunc(c) < 0) continue;
    2c48:	b20d      	sxth	r5, r1
    2c4a:	6823      	ldr	r3, [r4, #0]
    2c4c:	4628      	mov	r0, r5
    2c4e:	4798      	blx	r3
    2c50:	2800      	cmp	r0, #0
    2c52:	dbfa      	blt.n	2c4a <print_putchar+0x46>
    2c54:	bd38      	pop	{r3, r4, r5, pc}
    2c56:	bf00      	nop
    2c58:	100007d4 	.word	0x100007d4
    2c5c:	100007d0 	.word	0x100007d0
    2c60:	100007e8 	.word	0x100007e8
    2c64:	100007ec 	.word	0x100007ec
    2c68:	100007cc 	.word	0x100007cc
    2c6c:	100007dc 	.word	0x100007dc
    2c70:	100007d8 	.word	0x100007d8
    2c74:	100007e4 	.word	0x100007e4

Disassembly of section .text.print_fill:

00002c78 <print_fill>:
// #######################################################################################################################

//completa a impressao com os caracteres desejados
//n=quantos caracteres ja serao impressos, o que faltar
//a rotina preenche
static void print_fill(pPrint output, int n) {
    2c78:	b538      	push	{r3, r4, r5, lr}
    2c7a:	4605      	mov	r5, r0
    2c7c:	7a04      	ldrb	r4, [r0, #8]
    2c7e:	1a64      	subs	r4, r4, r1
	n = output->prefix - n;
	while (n-->0) print_putchar(output, output->fill);
    2c80:	2c00      	cmp	r4, #0
    2c82:	dd05      	ble.n	2c90 <print_fill+0x18>
    2c84:	7a69      	ldrb	r1, [r5, #9]
    2c86:	4628      	mov	r0, r5
    2c88:	f7ff ffbc 	bl	2c04 <print_putchar>
    2c8c:	3c01      	subs	r4, #1
    2c8e:	e7f7      	b.n	2c80 <print_fill+0x8>
}
    2c90:	bd38      	pop	{r3, r4, r5, pc}

Disassembly of section .text.print_int:

00002c92 <print_int>:
	while (s[d])
		print_putchar(output, s[d++]);
	print_fill(output, d);
}

static void print_int(pPrint output, int x) {
    2c92:	b570      	push	{r4, r5, r6, lr}
    2c94:	4605      	mov	r5, r0
	int d,sig;
	string digits;

	if (x<0) { sig = 1; x = -x; } else sig = 0;
    2c96:	2900      	cmp	r1, #0
	while (s[d])
		print_putchar(output, s[d++]);
	print_fill(output, d);
}

static void print_int(pPrint output, int x) {
    2c98:	b090      	sub	sp, #64	; 0x40
	int d,sig;
	string digits;

	if (x<0) { sig = 1; x = -x; } else sig = 0;
    2c9a:	bfba      	itte	lt
    2c9c:	4249      	neglt	r1, r1
    2c9e:	2201      	movlt	r2, #1
    2ca0:	2200      	movge	r2, #0
	d = 0;
    2ca2:	2300      	movs	r3, #0
	do	{
		digits[d++] = '0' + x%10;
    2ca4:	260a      	movs	r6, #10
    2ca6:	fb91 f0f6 	sdiv	r0, r1, r6
    2caa:	fb06 1110 	mls	r1, r6, r0, r1
    2cae:	3130      	adds	r1, #48	; 0x30
    2cb0:	f80d 1003 	strb.w	r1, [sp, r3]
    2cb4:	1c5c      	adds	r4, r3, #1
		x = x/10;
	}while (x);
    2cb6:	4601      	mov	r1, r0
    2cb8:	b108      	cbz	r0, 2cbe <print_int+0x2c>
	string digits;

	if (x<0) { sig = 1; x = -x; } else sig = 0;
	d = 0;
	do	{
		digits[d++] = '0' + x%10;
    2cba:	4623      	mov	r3, r4
    2cbc:	e7f3      	b.n	2ca6 <print_int+0x14>
		x = x/10;
	}while (x);
	if (sig) digits[d++] = '-';
    2cbe:	b12a      	cbz	r2, 2ccc <print_int+0x3a>
    2cc0:	aa10      	add	r2, sp, #64	; 0x40
    2cc2:	4414      	add	r4, r2
    2cc4:	222d      	movs	r2, #45	; 0x2d
    2cc6:	f804 2c40 	strb.w	r2, [r4, #-64]
    2cca:	1c9c      	adds	r4, r3, #2

	print_fill(output, d);
    2ccc:	4621      	mov	r1, r4
    2cce:	4628      	mov	r0, r5
    2cd0:	f7ff ffd2 	bl	2c78 <print_fill>
	while (d--) print_putchar(output, digits[d]);
    2cd4:	f114 34ff 	adds.w	r4, r4, #4294967295
    2cd8:	d305      	bcc.n	2ce6 <print_int+0x54>
    2cda:	f81d 1004 	ldrb.w	r1, [sp, r4]
    2cde:	4628      	mov	r0, r5
    2ce0:	f7ff ff90 	bl	2c04 <print_putchar>
    2ce4:	e7f6      	b.n	2cd4 <print_int+0x42>
}
    2ce6:	b010      	add	sp, #64	; 0x40
    2ce8:	bd70      	pop	{r4, r5, r6, pc}

Disassembly of section .text.print_long:

00002cea <print_long>:

static void print_long(pPrint output, long x) {
    2cea:	b570      	push	{r4, r5, r6, lr}
	int d; //digitos
	string digits;

	if (x<0) { print_putchar(output,'-'); x = -x; }
    2cec:	1e0c      	subs	r4, r1, #0

	print_fill(output, d);
	while (d--) print_putchar(output, digits[d]);
}

static void print_long(pPrint output, long x) {
    2cee:	b090      	sub	sp, #64	; 0x40
    2cf0:	4606      	mov	r6, r0
	int d; //digitos
	string digits;

	if (x<0) { print_putchar(output,'-'); x = -x; }
    2cf2:	da03      	bge.n	2cfc <print_long+0x12>
    2cf4:	212d      	movs	r1, #45	; 0x2d
    2cf6:	f7ff ff85 	bl	2c04 <print_putchar>
    2cfa:	4264      	negs	r4, r4

	print_fill(output, d);
	while (d--) print_putchar(output, digits[d]);
}

static void print_long(pPrint output, long x) {
    2cfc:	2500      	movs	r5, #0
	string digits;

	if (x<0) { print_putchar(output,'-'); x = -x; }
	d = 0;
	do	{
		digits[d++] = '0' + x%10;
    2cfe:	220a      	movs	r2, #10
    2d00:	fb94 f3f2 	sdiv	r3, r4, r2
    2d04:	fb02 4413 	mls	r4, r2, r3, r4
    2d08:	3501      	adds	r5, #1
    2d0a:	3430      	adds	r4, #48	; 0x30
    2d0c:	eb0d 0105 	add.w	r1, sp, r5
    2d10:	f801 4c01 	strb.w	r4, [r1, #-1]
		x = x/10;
	}while (x);
    2d14:	461c      	mov	r4, r3
    2d16:	2b00      	cmp	r3, #0
    2d18:	d1f2      	bne.n	2d00 <print_long+0x16>

	print_fill(output, d);
    2d1a:	4629      	mov	r1, r5
    2d1c:	4630      	mov	r0, r6
    2d1e:	f7ff ffab 	bl	2c78 <print_fill>
	while (d--) print_putchar(output, digits[d]);
    2d22:	f115 35ff 	adds.w	r5, r5, #4294967295
    2d26:	d305      	bcc.n	2d34 <print_long+0x4a>
    2d28:	f81d 1005 	ldrb.w	r1, [sp, r5]
    2d2c:	4630      	mov	r0, r6
    2d2e:	f7ff ff69 	bl	2c04 <print_putchar>
    2d32:	e7f6      	b.n	2d22 <print_long+0x38>
}
    2d34:	b010      	add	sp, #64	; 0x40
    2d36:	bd70      	pop	{r4, r5, r6, pc}

Disassembly of section .text.print_float:

00002d38 <print_float>:
	print_int(output, s);
}
#endif

#if ( STDIO_USE_FLOAT == pdON )
static void print_float(pPrint output, double x) {
    2d38:	b5f8      	push	{r3, r4, r5, r6, r7, lr}
    2d3a:	4616      	mov	r6, r2
    2d3c:	461d      	mov	r5, r3
    2d3e:	4604      	mov	r4, r0
	if (x<0) { print_putchar(output, '-'); x = -x; }
    2d40:	2200      	movs	r2, #0
    2d42:	2300      	movs	r3, #0
    2d44:	4630      	mov	r0, r6
    2d46:	4629      	mov	r1, r5
    2d48:	f7fd ff02 	bl	b50 <__aeabi_dcmplt>
    2d4c:	b128      	cbz	r0, 2d5a <print_float+0x22>
    2d4e:	212d      	movs	r1, #45	; 0x2d
    2d50:	4620      	mov	r0, r4
    2d52:	f7ff ff57 	bl	2c04 <print_putchar>
    2d56:	f105 4500 	add.w	r5, r5, #2147483648	; 0x80000000
	//parte inteira
	print_long(output, (long)x);
    2d5a:	4629      	mov	r1, r5
    2d5c:	4630      	mov	r0, r6
    2d5e:	f7fd ff1f 	bl	ba0 <__aeabi_d2iz>
    2d62:	4601      	mov	r1, r0
    2d64:	4607      	mov	r7, r0
    2d66:	4620      	mov	r0, r4
    2d68:	f7ff ffbf 	bl	2cea <print_long>
	if (output->precision<=0) return;
    2d6c:	7aa3      	ldrb	r3, [r4, #10]
    2d6e:	b3bb      	cbz	r3, 2de0 <print_float+0xa8>
	//parte fracionaria
	print_putchar(output, '.');
    2d70:	212e      	movs	r1, #46	; 0x2e
    2d72:	4620      	mov	r0, r4
    2d74:	f7ff ff46 	bl	2c04 <print_putchar>
	output->prefix = 0;
    2d78:	2300      	movs	r3, #0
    2d7a:	7223      	strb	r3, [r4, #8]
	x = x - (int)(x);
    2d7c:	4638      	mov	r0, r7
    2d7e:	f7fd fc0f 	bl	5a0 <__aeabi_i2d>
    2d82:	4602      	mov	r2, r0
    2d84:	460b      	mov	r3, r1
    2d86:	4630      	mov	r0, r6
    2d88:	4629      	mov	r1, r5
    2d8a:	f7fd fabb 	bl	304 <__aeabi_dsub>
    2d8e:	4606      	mov	r6, r0
    2d90:	460f      	mov	r7, r1
	while (output->precision-->0) {
    2d92:	7aa3      	ldrb	r3, [r4, #10]
    2d94:	1e5a      	subs	r2, r3, #1
    2d96:	72a2      	strb	r2, [r4, #10]
		x = x*10.0;
    2d98:	2200      	movs	r2, #0
	if (output->precision<=0) return;
	//parte fracionaria
	print_putchar(output, '.');
	output->prefix = 0;
	x = x - (int)(x);
	while (output->precision-->0) {
    2d9a:	b18b      	cbz	r3, 2dc0 <print_float+0x88>
		x = x*10.0;
    2d9c:	4b11      	ldr	r3, [pc, #68]	; (2de4 <print_float+0xac>)
    2d9e:	4630      	mov	r0, r6
    2da0:	4639      	mov	r1, r7
    2da2:	f7fd fc63 	bl	66c <__aeabi_dmul>
		if (x<1.0) print_putchar(output, '0');
    2da6:	2200      	movs	r2, #0
    2da8:	4b0f      	ldr	r3, [pc, #60]	; (2de8 <print_float+0xb0>)
	//parte fracionaria
	print_putchar(output, '.');
	output->prefix = 0;
	x = x - (int)(x);
	while (output->precision-->0) {
		x = x*10.0;
    2daa:	4606      	mov	r6, r0
    2dac:	460f      	mov	r7, r1
		if (x<1.0) print_putchar(output, '0');
    2dae:	f7fd fecf 	bl	b50 <__aeabi_dcmplt>
    2db2:	2800      	cmp	r0, #0
    2db4:	d0ed      	beq.n	2d92 <print_float+0x5a>
    2db6:	2130      	movs	r1, #48	; 0x30
    2db8:	4620      	mov	r0, r4
    2dba:	f7ff ff23 	bl	2c04 <print_putchar>
    2dbe:	e7e8      	b.n	2d92 <print_float+0x5a>
	}
	if (x>1) print_long(output, (long)x);
    2dc0:	4b09      	ldr	r3, [pc, #36]	; (2de8 <print_float+0xb0>)
    2dc2:	4630      	mov	r0, r6
    2dc4:	4639      	mov	r1, r7
    2dc6:	f7fd fee1 	bl	b8c <__aeabi_dcmpgt>
    2dca:	b148      	cbz	r0, 2de0 <print_float+0xa8>
    2dcc:	4639      	mov	r1, r7
    2dce:	4630      	mov	r0, r6
    2dd0:	f7fd fee6 	bl	ba0 <__aeabi_d2iz>
    2dd4:	4601      	mov	r1, r0
    2dd6:	4620      	mov	r0, r4
}
    2dd8:	e8bd 40f8 	ldmia.w	sp!, {r3, r4, r5, r6, r7, lr}
	x = x - (int)(x);
	while (output->precision-->0) {
		x = x*10.0;
		if (x<1.0) print_putchar(output, '0');
	}
	if (x>1) print_long(output, (long)x);
    2ddc:	f7ff bf85 	b.w	2cea <print_long>
    2de0:	bdf8      	pop	{r3, r4, r5, r6, r7, pc}
    2de2:	bf00      	nop
    2de4:	40240000 	.word	0x40240000
    2de8:	3ff00000 	.word	0x3ff00000

Disassembly of section .text.rprintf_RegisterDev:

00002dec <rprintf_RegisterDev>:

#if !defined(LINUX)
// Registra a função de saída do determinado dispositivo para usarmos o rprintf
void rprintf_RegisterDev(const u8 device, int(*putc)(n16) ) {
   	// regitrar a função de saida do dispositivo
   	switch(device) {
    2dec:	3804      	subs	r0, #4
    2dee:	2803      	cmp	r0, #3
    2df0:	d80b      	bhi.n	2e0a <rprintf_RegisterDev+0x1e>
    2df2:	e8df f000 	tbb	[pc, r0]
    2df6:	0402      	.short	0x0402
    2df8:	0806      	.short	0x0806
	case STDIO_DEV1: 	dev1_putc = putc; break;
    2dfa:	4b04      	ldr	r3, [pc, #16]	; (2e0c <rprintf_RegisterDev+0x20>)
    2dfc:	e004      	b.n	2e08 <rprintf_RegisterDev+0x1c>
   	case STDIO_DEV2: 	dev2_putc = putc; break;
    2dfe:	4b04      	ldr	r3, [pc, #16]	; (2e10 <rprintf_RegisterDev+0x24>)
    2e00:	e002      	b.n	2e08 <rprintf_RegisterDev+0x1c>
   	case STDIO_DEV3: 	dev3_putc = putc; break;
    2e02:	4b04      	ldr	r3, [pc, #16]	; (2e14 <rprintf_RegisterDev+0x28>)
    2e04:	e000      	b.n	2e08 <rprintf_RegisterDev+0x1c>
   	case STDIO_DEV4: 	dev4_putc = putc; break;
    2e06:	4b04      	ldr	r3, [pc, #16]	; (2e18 <rprintf_RegisterDev+0x2c>)
    2e08:	6019      	str	r1, [r3, #0]
    2e0a:	4770      	bx	lr
    2e0c:	100007cc 	.word	0x100007cc
    2e10:	100007dc 	.word	0x100007dc
    2e14:	100007d8 	.word	0x100007d8
    2e18:	100007e4 	.word	0x100007e4

Disassembly of section .text.lputchar_RegisterDev:

00002e1c <lputchar_RegisterDev>:
}
#endif // #if !defined(LINUX)

// Registra a função de saída padrão
void lputchar_RegisterDev(int (*func_putc)(n16)) {
	stdio_putc = func_putc;
    2e1c:	4b01      	ldr	r3, [pc, #4]	; (2e24 <lputchar_RegisterDev+0x8>)
    2e1e:	6018      	str	r0, [r3, #0]
    2e20:	4770      	bx	lr
    2e22:	bf00      	nop
    2e24:	100007d0 	.word	0x100007d0

Disassembly of section .text.ldebug_RegisterDev:

00002e28 <ldebug_RegisterDev>:
}

// Registra a função de saída padrão de LOG
void ldebug_RegisterDev(int (*putc)(n16)) {
	debug_putc = putc;
    2e28:	4b01      	ldr	r3, [pc, #4]	; (2e30 <ldebug_RegisterDev+0x8>)
    2e2a:	6018      	str	r0, [r3, #0]
    2e2c:	4770      	bx	lr
    2e2e:	bf00      	nop
    2e30:	100007e8 	.word	0x100007e8

Disassembly of section .text.lgetchar_RegisterDev:

00002e34 <lgetchar_RegisterDev>:
#endif // #if defined(FREE_RTOS)


// Registra a função de entrada padrão
void lgetchar_RegisterDev(int (*func_getc)(u8*)) {
	stdio_getc = func_getc;
    2e34:	4b01      	ldr	r3, [pc, #4]	; (2e3c <lgetchar_RegisterDev+0x8>)
    2e36:	6018      	str	r0, [r3, #0]
    2e38:	4770      	bx	lr
    2e3a:	bf00      	nop
    2e3c:	100007e0 	.word	0x100007e0

Disassembly of section .text.doprint:

00002e40 <doprint>:
	print_putchar(output, 'E');
	print_int(output, exp);
}
#endif

void doprint(pPrint output, cpchar fmt, va_list args) {
    2e40:	e92d 43f0 	stmdb	sp!, {r4, r5, r6, r7, r8, r9, lr}
    2e44:	4604      	mov	r4, r0
    2e46:	4615      	mov	r5, r2
    2e48:	4688      	mov	r8, r1
	char c, doformat = 0;

	output->count = 0;
    2e4a:	2100      	movs	r1, #0
	print_putchar(output, 'E');
	print_int(output, exp);
}
#endif

void doprint(pPrint output, cpchar fmt, va_list args) {
    2e4c:	b095      	sub	sp, #84	; 0x54
	char c, doformat = 0;

	output->count = 0;
    2e4e:	6041      	str	r1, [r0, #4]

	//repete o processo ate encontrar o terminador nulo
	do {
		c = *fmt++;
    2e50:	f108 0701 	add.w	r7, r8, #1
    2e54:	f898 6000 	ldrb.w	r6, [r8]

		if (doformat) {
    2e58:	2900      	cmp	r1, #0
    2e5a:	f000 818b 	beq.w	3174 <doprint+0x334>
			doformat = 0;

			if ( ((c=='l')||(c=='L')) &&(*fmt=='d')) {
    2e5e:	f006 03df 	and.w	r3, r6, #223	; 0xdf
    2e62:	2b4c      	cmp	r3, #76	; 0x4c
    2e64:	d10b      	bne.n	2e7e <doprint+0x3e>
    2e66:	f898 3001 	ldrb.w	r3, [r8, #1]
    2e6a:	2b64      	cmp	r3, #100	; 0x64
    2e6c:	d107      	bne.n	2e7e <doprint+0x3e>
				print_long(output, va_arg(args,long));
    2e6e:	6829      	ldr	r1, [r5, #0]
    2e70:	4620      	mov	r0, r4
    2e72:	1d2e      	adds	r6, r5, #4
    2e74:	f7ff ff39 	bl	2cea <print_long>
				fmt++;
    2e78:	f108 0702 	add.w	r7, r8, #2
    2e7c:	e0bd      	b.n	2ffa <doprint+0x1ba>
				continue;
			}

			switch (c) {
    2e7e:	2e63      	cmp	r6, #99	; 0x63
    2e80:	d03c      	beq.n	2efc <doprint+0xbc>
    2e82:	d819      	bhi.n	2eb8 <doprint+0x78>
    2e84:	2e53      	cmp	r6, #83	; 0x53
    2e86:	f000 808c 	beq.w	2fa2 <doprint+0x162>
    2e8a:	d80c      	bhi.n	2ea6 <doprint+0x66>
    2e8c:	2e43      	cmp	r6, #67	; 0x43
    2e8e:	d035      	beq.n	2efc <doprint+0xbc>
    2e90:	2e44      	cmp	r6, #68	; 0x44
    2e92:	d036      	beq.n	2f02 <doprint+0xc2>
    2e94:	2e25      	cmp	r6, #37	; 0x25
    2e96:	f040 814f 	bne.w	3138 <doprint+0x2f8>
			case '%' : print_putchar(output, '%'); break;
    2e9a:	4631      	mov	r1, r6
    2e9c:	4620      	mov	r0, r4
    2e9e:	f7ff feb1 	bl	2c04 <print_putchar>
    2ea2:	462e      	mov	r6, r5
    2ea4:	e17b      	b.n	319e <doprint+0x35e>
				print_long(output, va_arg(args,long));
				fmt++;
				continue;
			}

			switch (c) {
    2ea6:	2e58      	cmp	r6, #88	; 0x58
    2ea8:	d04f      	beq.n	2f4a <doprint+0x10a>
    2eaa:	2e62      	cmp	r6, #98	; 0x62
    2eac:	f000 80d4 	beq.w	3058 <doprint+0x218>
    2eb0:	2e55      	cmp	r6, #85	; 0x55
    2eb2:	f040 8141 	bne.w	3138 <doprint+0x2f8>
    2eb6:	e027      	b.n	2f08 <doprint+0xc8>
    2eb8:	2e6b      	cmp	r6, #107	; 0x6b
    2eba:	f000 8088 	beq.w	2fce <doprint+0x18e>
    2ebe:	d811      	bhi.n	2ee4 <doprint+0xa4>
    2ec0:	2e65      	cmp	r6, #101	; 0x65
    2ec2:	f000 80e8 	beq.w	3096 <doprint+0x256>
    2ec6:	d31c      	bcc.n	2f02 <doprint+0xc2>
    2ec8:	2e66      	cmp	r6, #102	; 0x66
    2eca:	f040 8135 	bne.w	3138 <doprint+0x2f8>
			#endif
			#if ( STDIO_USE_BIN == pdON )
			case 'b' : print_bin(output, va_arg(args,long)); break;
			#endif
			#if ( STDIO_USE_FLOAT == pdON )
			case 'f' : print_float(output, va_arg(args, double)); break;
    2ece:	3507      	adds	r5, #7
    2ed0:	f025 0507 	bic.w	r5, r5, #7
    2ed4:	e9d5 2300 	ldrd	r2, r3, [r5]
    2ed8:	4620      	mov	r0, r4
    2eda:	f105 0608 	add.w	r6, r5, #8
    2ede:	f7ff ff2b 	bl	2d38 <print_float>
    2ee2:	e15c      	b.n	319e <doprint+0x35e>
				print_long(output, va_arg(args,long));
				fmt++;
				continue;
			}

			switch (c) {
    2ee4:	2e74      	cmp	r6, #116	; 0x74
    2ee6:	f000 8094 	beq.w	3012 <doprint+0x1d2>
    2eea:	d802      	bhi.n	2ef2 <doprint+0xb2>
    2eec:	2e73      	cmp	r6, #115	; 0x73
    2eee:	d058      	beq.n	2fa2 <doprint+0x162>
    2ef0:	e122      	b.n	3138 <doprint+0x2f8>
    2ef2:	2e75      	cmp	r6, #117	; 0x75
    2ef4:	d008      	beq.n	2f08 <doprint+0xc8>
    2ef6:	2e78      	cmp	r6, #120	; 0x78
    2ef8:	d027      	beq.n	2f4a <doprint+0x10a>
    2efa:	e11d      	b.n	3138 <doprint+0x2f8>
			case '%' : print_putchar(output, '%'); break;
			case 'C' :
			case 'c' : print_putchar(output, va_arg(args,int)); break;
    2efc:	1d2e      	adds	r6, r5, #4
    2efe:	7829      	ldrb	r1, [r5, #0]
    2f00:	e083      	b.n	300a <doprint+0x1ca>
			case 'D' :
			case 'd' : print_int(output, va_arg(args,int)); break;
    2f02:	1d2e      	adds	r6, r5, #4
    2f04:	6829      	ldr	r1, [r5, #0]
    2f06:	e113      	b.n	3130 <doprint+0x2f0>
			case 'U' :
			case 'u' : print_uint(output, va_arg(args,int)); break;
    2f08:	1d2e      	adds	r6, r5, #4
    2f0a:	682b      	ldr	r3, [r5, #0]
	unsigned int d; //digitos
	string digits;

	d = 0;
	do	{
		digits[d++] = '0' + x%10;
    2f0c:	f10d 0810 	add.w	r8, sp, #16

static void print_uint(pPrint output, unsigned int x) {
	unsigned int d; //digitos
	string digits;

	d = 0;
    2f10:	2500      	movs	r5, #0
	do	{
		digits[d++] = '0' + x%10;
    2f12:	210a      	movs	r1, #10
    2f14:	fbb3 f2f1 	udiv	r2, r3, r1
    2f18:	fb01 3312 	mls	r3, r1, r2, r3
    2f1c:	3501      	adds	r5, #1
    2f1e:	3330      	adds	r3, #48	; 0x30
    2f20:	eb08 0005 	add.w	r0, r8, r5
    2f24:	f800 3c01 	strb.w	r3, [r0, #-1]
		x = x/10;
	}while (x);
    2f28:	4613      	mov	r3, r2
    2f2a:	2a00      	cmp	r2, #0
    2f2c:	d1f2      	bne.n	2f14 <doprint+0xd4>

	print_fill(output, d);
    2f2e:	4629      	mov	r1, r5
    2f30:	4620      	mov	r0, r4
    2f32:	f7ff fea1 	bl	2c78 <print_fill>
	while (d--) print_putchar(output, digits[d]);
    2f36:	f115 35ff 	adds.w	r5, r5, #4294967295
    2f3a:	f0c0 8130 	bcc.w	319e <doprint+0x35e>
    2f3e:	f818 1005 	ldrb.w	r1, [r8, r5]
    2f42:	4620      	mov	r0, r4
    2f44:	f7ff fe5e 	bl	2c04 <print_putchar>
    2f48:	e7f5      	b.n	2f36 <doprint+0xf6>
}
#endif

#if ( STDIO_USE_HEX == pdON )
static void print_hex(pPrint output, unsigned int x) {
	const char HexTable[16] = {
    2f4a:	46ee      	mov	lr, sp
    2f4c:	4b97      	ldr	r3, [pc, #604]	; (31ac <doprint+0x36c>)
			case 'd' : print_int(output, va_arg(args,int)); break;
			case 'U' :
			case 'u' : print_uint(output, va_arg(args,int)); break;
			#if ( STDIO_USE_HEX == pdON )
			case 'X' :
			case 'x' : print_hex(output, va_arg(args,int));	break;
    2f4e:	682a      	ldr	r2, [r5, #0]
    2f50:	1d2e      	adds	r6, r5, #4
}
#endif

#if ( STDIO_USE_HEX == pdON )
static void print_hex(pPrint output, unsigned int x) {
	const char HexTable[16] = {
    2f52:	f103 0c10 	add.w	ip, r3, #16
    2f56:	4675      	mov	r5, lr
    2f58:	6818      	ldr	r0, [r3, #0]
    2f5a:	6859      	ldr	r1, [r3, #4]
    2f5c:	3308      	adds	r3, #8
    2f5e:	c503      	stmia	r5!, {r0, r1}
    2f60:	4563      	cmp	r3, ip
    2f62:	46ae      	mov	lr, r5
    2f64:	d1f7      	bne.n	2f56 <doprint+0x116>
		'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'
	};
	char digits[16];

	int d = 0;
    2f66:	2500      	movs	r5, #0
	do	{
		digits[d++] = HexTable[x&0xF];
    2f68:	f10d 0810 	add.w	r8, sp, #16
    2f6c:	f002 030f 	and.w	r3, r2, #15
    2f70:	a814      	add	r0, sp, #80	; 0x50
    2f72:	4403      	add	r3, r0
    2f74:	3501      	adds	r5, #1
    2f76:	f813 3c50 	ldrb.w	r3, [r3, #-80]
    2f7a:	eb08 0105 	add.w	r1, r8, r5
		x = x>>4;
	}while (x);
    2f7e:	0912      	lsrs	r2, r2, #4
	};
	char digits[16];

	int d = 0;
	do	{
		digits[d++] = HexTable[x&0xF];
    2f80:	f801 3c01 	strb.w	r3, [r1, #-1]
		x = x>>4;
	}while (x);
    2f84:	d1f2      	bne.n	2f6c <doprint+0x12c>

	//print_putchar(output, '0');
	//print_putchar(output, 'x');
	print_fill(output, d);
    2f86:	4629      	mov	r1, r5
    2f88:	4620      	mov	r0, r4
    2f8a:	f7ff fe75 	bl	2c78 <print_fill>
	while (d--) print_putchar(output, digits[d]);
    2f8e:	f115 35ff 	adds.w	r5, r5, #4294967295
    2f92:	f0c0 8104 	bcc.w	319e <doprint+0x35e>
    2f96:	f818 1005 	ldrb.w	r1, [r8, r5]
    2f9a:	4620      	mov	r0, r4
    2f9c:	f7ff fe32 	bl	2c04 <print_putchar>
    2fa0:	e7f5      	b.n	2f8e <doprint+0x14e>
			#if ( STDIO_USE_HEX == pdON )
			case 'X' :
			case 'x' : print_hex(output, va_arg(args,int));	break;
			#endif
			case 'S' :
			case 's' : print_string(output, (char*)va_arg(args,int)); break;
    2fa2:	1d2e      	adds	r6, r5, #4
    2fa4:	682d      	ldr	r5, [r5, #0]
	while (n-->0) print_putchar(output, output->fill);
}

static void print_string(pPrint output, char * s) {
	int d = 0;
	if (s==NULL) return;
    2fa6:	2d00      	cmp	r5, #0
    2fa8:	f000 80f9 	beq.w	319e <doprint+0x35e>
    2fac:	46a9      	mov	r9, r5
    2fae:	ebc5 0109 	rsb	r1, r5, r9
	while (s[d])
    2fb2:	f819 8b01 	ldrb.w	r8, [r9], #1
    2fb6:	f1b8 0f00 	cmp.w	r8, #0
    2fba:	d004      	beq.n	2fc6 <doprint+0x186>
		print_putchar(output, s[d++]);
    2fbc:	4641      	mov	r1, r8
    2fbe:	4620      	mov	r0, r4
    2fc0:	f7ff fe20 	bl	2c04 <print_putchar>
    2fc4:	e7f3      	b.n	2fae <doprint+0x16e>
	print_fill(output, d);
    2fc6:	4620      	mov	r0, r4
    2fc8:	f7ff fe56 	bl	2c78 <print_fill>
    2fcc:	e0e7      	b.n	319e <doprint+0x35e>
			case 'x' : print_hex(output, va_arg(args,int));	break;
			#endif
			case 'S' :
			case 's' : print_string(output, (char*)va_arg(args,int)); break;
			#if ( STDIO_USE_SUBINT == pdON )
			case 'k' : print_intF(output, va_arg(args,long));	break;
    2fce:	1d2e      	adds	r6, r5, #4
    2fd0:	6829      	ldr	r1, [r5, #0]
	while (d--) print_putchar(output, digits[d]);
}

#if ( STDIO_USE_SUBINT == pdON )
static void print_intF(pPrint output, long x) {
	int b = 0;
    2fd2:	2500      	movs	r5, #0
	while (x>10240) { x = x/1024; b++; }
    2fd4:	f5b1 5f20 	cmp.w	r1, #10240	; 0x2800
    2fd8:	dd02      	ble.n	2fe0 <doprint+0x1a0>
    2fda:	1289      	asrs	r1, r1, #10
    2fdc:	3501      	adds	r5, #1
    2fde:	e7f9      	b.n	2fd4 <doprint+0x194>
	print_int(output, x);
    2fe0:	4620      	mov	r0, r4
    2fe2:	f7ff fe56 	bl	2c92 <print_int>
	if (b==1) print_putchar(output, 'k');
    2fe6:	2d01      	cmp	r5, #1
    2fe8:	d101      	bne.n	2fee <doprint+0x1ae>
    2fea:	216b      	movs	r1, #107	; 0x6b
    2fec:	e00d      	b.n	300a <doprint+0x1ca>
	if (b==2) print_putchar(output, 'M');
    2fee:	2d02      	cmp	r5, #2
    2ff0:	d107      	bne.n	3002 <doprint+0x1c2>
    2ff2:	214d      	movs	r1, #77	; 0x4d
    2ff4:	4620      	mov	r0, r4
    2ff6:	f7ff fe05 	bl	2c04 <print_putchar>
			case 'x' : print_hex(output, va_arg(args,int));	break;
			#endif
			case 'S' :
			case 's' : print_string(output, (char*)va_arg(args,int)); break;
			#if ( STDIO_USE_SUBINT == pdON )
			case 'k' : print_intF(output, va_arg(args,long));	break;
    2ffa:	4635      	mov	r5, r6
    2ffc:	2100      	movs	r1, #0
	//repete o processo ate encontrar o terminador nulo
	do {
		c = *fmt++;

		if (doformat) {
			doformat = 0;
    2ffe:	46b8      	mov	r8, r7
    3000:	e726      	b.n	2e50 <doprint+0x10>
	int b = 0;
	while (x>10240) { x = x/1024; b++; }
	print_int(output, x);
	if (b==1) print_putchar(output, 'k');
	if (b==2) print_putchar(output, 'M');
	if (b==3) print_putchar(output, 'G');
    3002:	2d03      	cmp	r5, #3
    3004:	f040 80cb 	bne.w	319e <doprint+0x35e>
    3008:	2147      	movs	r1, #71	; 0x47
    300a:	4620      	mov	r0, r4
    300c:	f7ff fdfa 	bl	2c04 <print_putchar>
    3010:	e0c5      	b.n	319e <doprint+0x35e>
			case 's' : print_string(output, (char*)va_arg(args,int)); break;
			#if ( STDIO_USE_SUBINT == pdON )
			case 'k' : print_intF(output, va_arg(args,long));	break;
			#endif
			#if ( STDIO_USE_TIME == pdON )
			case 't' : print_time(output, va_arg(args,long)); break;
    3012:	f8d5 9000 	ldr.w	r9, [r5]
	s = x%60;	x = x/60;
	m = x%60;	x = x/60;
	h = x;

	//formato = "00:00'00"
	output->prefix = 2;
    3016:	2302      	movs	r3, #2
    3018:	7223      	strb	r3, [r4, #8]
	output->fill = '0';
	print_int(output, h);	print_putchar(output, ':');
    301a:	f44f 6161 	mov.w	r1, #3600	; 0xe10
	m = x%60;	x = x/60;
	h = x;

	//formato = "00:00'00"
	output->prefix = 2;
	output->fill = '0';
    301e:	2330      	movs	r3, #48	; 0x30
    3020:	7263      	strb	r3, [r4, #9]
	print_int(output, h);	print_putchar(output, ':');
    3022:	fb99 f1f1 	sdiv	r1, r9, r1
    3026:	4620      	mov	r0, r4
    3028:	f7ff fe33 	bl	2c92 <print_int>
			case 's' : print_string(output, (char*)va_arg(args,int)); break;
			#if ( STDIO_USE_SUBINT == pdON )
			case 'k' : print_intF(output, va_arg(args,long));	break;
			#endif
			#if ( STDIO_USE_TIME == pdON )
			case 't' : print_time(output, va_arg(args,long)); break;
    302c:	1d2e      	adds	r6, r5, #4
	h = x;

	//formato = "00:00'00"
	output->prefix = 2;
	output->fill = '0';
	print_int(output, h);	print_putchar(output, ':');
    302e:	213a      	movs	r1, #58	; 0x3a
	print_int(output, m);	print_putchar(output, 39);
    3030:	253c      	movs	r5, #60	; 0x3c
	h = x;

	//formato = "00:00'00"
	output->prefix = 2;
	output->fill = '0';
	print_int(output, h);	print_putchar(output, ':');
    3032:	4620      	mov	r0, r4
    3034:	f7ff fde6 	bl	2c04 <print_putchar>
	print_int(output, m);	print_putchar(output, 39);
    3038:	fb99 f8f5 	sdiv	r8, r9, r5
    303c:	fb98 f1f5 	sdiv	r1, r8, r5
    3040:	4620      	mov	r0, r4
    3042:	fb05 8111 	mls	r1, r5, r1, r8
    3046:	f7ff fe24 	bl	2c92 <print_int>
    304a:	2127      	movs	r1, #39	; 0x27
    304c:	4620      	mov	r0, r4
    304e:	f7ff fdd9 	bl	2c04 <print_putchar>
	print_int(output, s);
    3052:	fb05 9118 	mls	r1, r5, r8, r9
    3056:	e06b      	b.n	3130 <doprint+0x2f0>

#if ( STDIO_USE_BIN == pdON )
static void print_bin(pPrint output, long x) {
	string digits;
	int d = 0;
	output->fill = '0';
    3058:	2230      	movs	r2, #48	; 0x30
			#endif
			#if ( STDIO_USE_TIME == pdON )
			case 't' : print_time(output, va_arg(args,long)); break;
			#endif
			#if ( STDIO_USE_BIN == pdON )
			case 'b' : print_bin(output, va_arg(args,long)); break;
    305a:	682b      	ldr	r3, [r5, #0]
    305c:	1d2e      	adds	r6, r5, #4

#if ( STDIO_USE_BIN == pdON )
static void print_bin(pPrint output, long x) {
	string digits;
	int d = 0;
	output->fill = '0';
    305e:	7262      	strb	r2, [r4, #9]
#endif

#if ( STDIO_USE_BIN == pdON )
static void print_bin(pPrint output, long x) {
	string digits;
	int d = 0;
    3060:	2500      	movs	r5, #0
	output->fill = '0';
	do {
		digits[d++] = '0'+(x&1);
    3062:	f10d 0810 	add.w	r8, sp, #16
    3066:	f003 0201 	and.w	r2, r3, #1
    306a:	3501      	adds	r5, #1
    306c:	eb08 0105 	add.w	r1, r8, r5
    3070:	3230      	adds	r2, #48	; 0x30
		x = x>>1;
	}while (x);
    3072:	105b      	asrs	r3, r3, #1
static void print_bin(pPrint output, long x) {
	string digits;
	int d = 0;
	output->fill = '0';
	do {
		digits[d++] = '0'+(x&1);
    3074:	f801 2c01 	strb.w	r2, [r1, #-1]
		x = x>>1;
	}while (x);
    3078:	d1f5      	bne.n	3066 <doprint+0x226>
	//print_putchar(output, '0');
	//print_putchar(output, 'b');
	print_fill(output, d);
    307a:	4629      	mov	r1, r5
    307c:	4620      	mov	r0, r4
    307e:	f7ff fdfb 	bl	2c78 <print_fill>
	while (d--) print_putchar(output, digits[d]);
    3082:	f115 35ff 	adds.w	r5, r5, #4294967295
    3086:	f0c0 808a 	bcc.w	319e <doprint+0x35e>
    308a:	f818 1005 	ldrb.w	r1, [r8, r5]
    308e:	4620      	mov	r0, r4
    3090:	f7ff fdb8 	bl	2c04 <print_putchar>
    3094:	e7f5      	b.n	3082 <doprint+0x242>
			#if ( STDIO_USE_BIN == pdON )
			case 'b' : print_bin(output, va_arg(args,long)); break;
			#endif
			#if ( STDIO_USE_FLOAT == pdON )
			case 'f' : print_float(output, va_arg(args, double)); break;
			case 'e' : print_exp(output, va_arg(args, double)); break;
    3096:	3507      	adds	r5, #7
    3098:	f025 0507 	bic.w	r5, r5, #7
    309c:	f8d5 8000 	ldr.w	r8, [r5]
    30a0:	f105 0608 	add.w	r6, r5, #8
    30a4:	686d      	ldr	r5, [r5, #4]
	if (x>1) print_long(output, (long)x);
}

static void print_exp(pPrint output, double x) {
	int exp = 0;
	if (x<0) { print_putchar(output, '-'); x = -x; }
    30a6:	2200      	movs	r2, #0
    30a8:	2300      	movs	r3, #0
    30aa:	4640      	mov	r0, r8
    30ac:	4629      	mov	r1, r5
    30ae:	f7fd fd4f 	bl	b50 <__aeabi_dcmplt>
    30b2:	b128      	cbz	r0, 30c0 <doprint+0x280>
    30b4:	212d      	movs	r1, #45	; 0x2d
    30b6:	4620      	mov	r0, r4
    30b8:	f7ff fda4 	bl	2c04 <print_putchar>
    30bc:	f105 4500 	add.w	r5, r5, #2147483648	; 0x80000000
	if (x!=0) {
    30c0:	2200      	movs	r2, #0
    30c2:	2300      	movs	r3, #0
    30c4:	4640      	mov	r0, r8
    30c6:	4629      	mov	r1, r5
    30c8:	f7fd fd38 	bl	b3c <__aeabi_dcmpeq>
    30cc:	bb20      	cbnz	r0, 3118 <doprint+0x2d8>
    30ce:	4681      	mov	r9, r0
		while (x<1) { x = x*10; exp--; }
    30d0:	2200      	movs	r2, #0
    30d2:	4b37      	ldr	r3, [pc, #220]	; (31b0 <doprint+0x370>)
    30d4:	4640      	mov	r0, r8
    30d6:	4629      	mov	r1, r5
    30d8:	f7fd fd3a 	bl	b50 <__aeabi_dcmplt>
    30dc:	b150      	cbz	r0, 30f4 <doprint+0x2b4>
    30de:	4640      	mov	r0, r8
    30e0:	4629      	mov	r1, r5
    30e2:	2200      	movs	r2, #0
    30e4:	4b33      	ldr	r3, [pc, #204]	; (31b4 <doprint+0x374>)
    30e6:	f7fd fac1 	bl	66c <__aeabi_dmul>
    30ea:	f109 39ff 	add.w	r9, r9, #4294967295
    30ee:	4680      	mov	r8, r0
    30f0:	460d      	mov	r5, r1
    30f2:	e7ed      	b.n	30d0 <doprint+0x290>
		while (x>10){ x = x/10; exp++; }
    30f4:	2200      	movs	r2, #0
    30f6:	4b2f      	ldr	r3, [pc, #188]	; (31b4 <doprint+0x374>)
    30f8:	4640      	mov	r0, r8
    30fa:	4629      	mov	r1, r5
    30fc:	f7fd fd46 	bl	b8c <__aeabi_dcmpgt>
    3100:	b160      	cbz	r0, 311c <doprint+0x2dc>
    3102:	4640      	mov	r0, r8
    3104:	4629      	mov	r1, r5
    3106:	2200      	movs	r2, #0
    3108:	4b2a      	ldr	r3, [pc, #168]	; (31b4 <doprint+0x374>)
    310a:	f7fd fbd9 	bl	8c0 <__aeabi_ddiv>
    310e:	f109 0901 	add.w	r9, r9, #1
    3112:	4680      	mov	r8, r0
    3114:	460d      	mov	r5, r1
    3116:	e7ed      	b.n	30f4 <doprint+0x2b4>
	}
	if (x>1) print_long(output, (long)x);
}

static void print_exp(pPrint output, double x) {
	int exp = 0;
    3118:	f04f 0900 	mov.w	r9, #0
	if (x<0) { print_putchar(output, '-'); x = -x; }
	if (x!=0) {
		while (x<1) { x = x*10; exp--; }
		while (x>10){ x = x/10; exp++; }
	}
	print_float(output, x);
    311c:	4642      	mov	r2, r8
    311e:	462b      	mov	r3, r5
    3120:	4620      	mov	r0, r4
    3122:	f7ff fe09 	bl	2d38 <print_float>
	print_putchar(output, 'E');
    3126:	2145      	movs	r1, #69	; 0x45
    3128:	4620      	mov	r0, r4
    312a:	f7ff fd6b 	bl	2c04 <print_putchar>
	print_int(output, exp);
    312e:	4649      	mov	r1, r9
    3130:	4620      	mov	r0, r4
    3132:	f7ff fdae 	bl	2c92 <print_int>
    3136:	e032      	b.n	319e <doprint+0x35e>
			case 'f' : print_float(output, va_arg(args, double)); break;
			case 'e' : print_exp(output, va_arg(args, double)); break;
			#endif
			default :
				// preencher com '0'?
				if ( (c=='0')&&(output->prefix==0) ) {
    3138:	2e30      	cmp	r6, #48	; 0x30
    313a:	d103      	bne.n	3144 <doprint+0x304>
    313c:	7a23      	ldrb	r3, [r4, #8]
    313e:	b953      	cbnz	r3, 3156 <doprint+0x316>
					doformat = 1; output->fill = '0';
    3140:	7266      	strb	r6, [r4, #9]
    3142:	e01e      	b.n	3182 <doprint+0x342>
					continue;
				}

				// vai indicar a precisao
				if (c=='.') {
    3144:	2e2e      	cmp	r6, #46	; 0x2e
    3146:	d106      	bne.n	3156 <doprint+0x316>
					doformat = 1;
					output->precision = (*fmt++)-'0';
    3148:	f898 3001 	ldrb.w	r3, [r8, #1]
    314c:	f108 0702 	add.w	r7, r8, #2
    3150:	3b30      	subs	r3, #48	; 0x30
    3152:	72a3      	strb	r3, [r4, #10]
    3154:	e015      	b.n	3182 <doprint+0x342>
					continue;
				}

				//esta indicando o prefixo...
				if ( (c>='0')&&(c<='9') ) {
    3156:	f1a6 0330 	sub.w	r3, r6, #48	; 0x30
    315a:	2b09      	cmp	r3, #9
    315c:	d808      	bhi.n	3170 <doprint+0x330>
					doformat = 1;
					output->prefix = output->prefix*10 + (c - '0');
    315e:	7a23      	ldrb	r3, [r4, #8]
					continue;
				}

				//esta indicando o prefixo...
				if ( (c>='0')&&(c<='9') ) {
					doformat = 1;
    3160:	2101      	movs	r1, #1
					output->prefix = output->prefix*10 + (c - '0');
    3162:	eb03 0383 	add.w	r3, r3, r3, lsl #2
    3166:	eb06 0643 	add.w	r6, r6, r3, lsl #1
    316a:	3e30      	subs	r6, #48	; 0x30
    316c:	7226      	strb	r6, [r4, #8]
					continue;
    316e:	e746      	b.n	2ffe <doprint+0x1be>
				}
				print_putchar(output, '?');
    3170:	213f      	movs	r1, #63	; 0x3f
    3172:	e00d      	b.n	3190 <doprint+0x350>
				break;
			}
			continue;
		}

		if (c=='%')	{
    3174:	2e25      	cmp	r6, #37	; 0x25
    3176:	d107      	bne.n	3188 <doprint+0x348>
			doformat = 1;
			output->prefix = 0;
			output->precision = 5;
    3178:	2305      	movs	r3, #5
    317a:	72a3      	strb	r3, [r4, #10]
			output->fill = ' ';
    317c:	2320      	movs	r3, #32
			continue;
		}

		if (c=='%')	{
			doformat = 1;
			output->prefix = 0;
    317e:	7221      	strb	r1, [r4, #8]
			output->precision = 5;
			output->fill = ' ';
    3180:	7263      	strb	r3, [r4, #9]
			continue;
    3182:	462e      	mov	r6, r5
			}
			continue;
		}

		if (c=='%')	{
			doformat = 1;
    3184:	2101      	movs	r1, #1
			output->prefix = 0;
			output->precision = 5;
			output->fill = ' ';
			continue;
    3186:	e00b      	b.n	31a0 <doprint+0x360>
		}

		// Não imprime o caractere nulo (foi incluso essa cláusula em 27/06/2014)
		// o caractere nulo somente será impresso caso for chamado sformat (foi incluso essa cláusula em 14/07/2014)
		//	Pois é preciso adicionar o finalizador de string
		if ( (c > 0) || ((c==0) && (output->isSformat)))
    3188:	b90e      	cbnz	r6, 318e <doprint+0x34e>
    318a:	7ae3      	ldrb	r3, [r4, #11]
    318c:	b153      	cbz	r3, 31a4 <doprint+0x364>
			print_putchar(output, c);
    318e:	4631      	mov	r1, r6
    3190:	4620      	mov	r0, r4
    3192:	f7ff fd37 	bl	2c04 <print_putchar>
	} while (c);
    3196:	2e00      	cmp	r6, #0
    3198:	f47f af30 	bne.w	2ffc <doprint+0x1bc>
    319c:	e002      	b.n	31a4 <doprint+0x364>
	//repete o processo ate encontrar o terminador nulo
	do {
		c = *fmt++;

		if (doformat) {
			doformat = 0;
    319e:	2100      	movs	r1, #0
	print_putchar(output, 'E');
	print_int(output, exp);
}
#endif

void doprint(pPrint output, cpchar fmt, va_list args) {
    31a0:	4635      	mov	r5, r6
    31a2:	e72c      	b.n	2ffe <doprint+0x1be>
		// o caractere nulo somente será impresso caso for chamado sformat (foi incluso essa cláusula em 14/07/2014)
		//	Pois é preciso adicionar o finalizador de string
		if ( (c > 0) || ((c==0) && (output->isSformat)))
			print_putchar(output, c);
	} while (c);
}
    31a4:	b015      	add	sp, #84	; 0x54
    31a6:	e8bd 83f0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, r9, pc}
    31aa:	bf00      	nop
    31ac:	00004b4c 	.word	0x00004b4c
    31b0:	3ff00000 	.word	0x3ff00000
    31b4:	40240000 	.word	0x40240000

Disassembly of section .text.lgetchar:

000031b8 <lgetchar>:

// #######################################################################################################################
// FUNÇÕES DE ENTRADA E DE SAÍDAS DE IMPRESSÃO NOS DISPOSITIVOS
// #######################################################################################################################
int lgetchar(u8 *ch) {
	return stdio_getc(ch);
    31b8:	4b01      	ldr	r3, [pc, #4]	; (31c0 <lgetchar+0x8>)
    31ba:	681b      	ldr	r3, [r3, #0]
    31bc:	4718      	bx	r3
    31be:	bf00      	nop
    31c0:	100007e0 	.word	0x100007e0

Disassembly of section .text.rprintf:

000031c4 <rprintf>:
//	lprintf("BIN: 0b%b 0b%2b"CMD_TERMINATOR, 0x123, 0x456);
//	lprintf("String: %s"CMD_TERMINATOR, "imprimindo");
#if defined(LINUX)
int rprintf(const char* fmt, ...) {
#else
int rprintf(const u8 device, const cpchar fmt, ...) {
    31c4:	b40e      	push	{r1, r2, r3}
    31c6:	b53f      	push	{r0, r1, r2, r3, r4, r5, lr}
    31c8:	aa07      	add	r2, sp, #28
    31ca:	f852 1b04 	ldr.w	r1, [r2], #4
	#endif

	#if !defined(LINUX)
	output.device = device;			// Sinaliza qual dipositivo de saída deve ser impresso
	#endif
	output.buf = NULL;				// Sinaliza que não vamos usar buffer para formatação de string
    31ce:	2300      	movs	r3, #0
	// Travar o recurso de saída para transmissão completa da mensagem, esperar MAX_DELAY caso o recurso está sendo usado
	ret = xSemaphoreTake(mutex, portMAX_DELAY);
	#endif

	#if !defined(LINUX)
	output.device = device;			// Sinaliza qual dipositivo de saída deve ser impresso
    31d0:	f88d 0014 	strb.w	r0, [sp, #20]
	output.buf = NULL;				// Sinaliza que não vamos usar buffer para formatação de string
	output.isSformat = 0;			// Sinaliza que não é um sformat

	va_list args;					// Cria var para captura de argumentos (fmt) no stack da chamada de função
	va_start(args, fmt);			// Captura os argumentos após fmt
	doprint(&output, fmt, args);	// Faz a formatação da string com ftm e args e manda imprimir
    31d4:	a802      	add	r0, sp, #8
	#endif

	#if !defined(LINUX)
	output.device = device;			// Sinaliza qual dipositivo de saída deve ser impresso
	#endif
	output.buf = NULL;				// Sinaliza que não vamos usar buffer para formatação de string
    31d6:	9302      	str	r3, [sp, #8]
	output.isSformat = 0;			// Sinaliza que não é um sformat
    31d8:	f88d 3013 	strb.w	r3, [sp, #19]

	va_list args;					// Cria var para captura de argumentos (fmt) no stack da chamada de função
	va_start(args, fmt);			// Captura os argumentos após fmt
    31dc:	9201      	str	r2, [sp, #4]
	doprint(&output, fmt, args);	// Faz a formatação da string com ftm e args e manda imprimir
    31de:	f7ff fe2f 	bl	2e40 <doprint>
	// Liberar o recuro de saida
	xSemaphoreGive(mutex);
	#endif

  	return ret;
}
    31e2:	2001      	movs	r0, #1
    31e4:	b006      	add	sp, #24
    31e6:	f85d eb04 	ldr.w	lr, [sp], #4
    31ea:	b003      	add	sp, #12
    31ec:	4770      	bx	lr

Disassembly of section .text.buffer_Init:

000031ee <buffer_Init>:
void buffer_Init(buffer_t *buffer, u8 *start, u16 size) {
	// set start pointer of the buffer
	buffer->dataptr = start;
	buffer->size = size;
	// initialize index and length
	buffer->dataindex = 0;
    31ee:	2300      	movs	r3, #0
// Parametros: 	Endereço da estrutura do buffer, endereço do vetor de dados e o tamanho do vetor
// Retorna: 	Nada
//------------------------------------------------------------------------------------------------------------------
void buffer_Init(buffer_t *buffer, u8 *start, u16 size) {
	// set start pointer of the buffer
	buffer->dataptr = start;
    31f0:	6001      	str	r1, [r0, #0]
	buffer->size = size;
    31f2:	8082      	strh	r2, [r0, #4]
	// initialize index and length
	buffer->dataindex = 0;
    31f4:	8103      	strh	r3, [r0, #8]
	buffer->datalength = 0;
    31f6:	80c3      	strh	r3, [r0, #6]
    31f8:	4770      	bx	lr

Disassembly of section .text.buffer_GetFromFront:

000031fa <buffer_GetFromFront>:
//------------------------------------------------------------------------------------------------------------------
// Descrição: 	Retorna com o primeiro caractere do buffer e retira-o do buffer
// Parametros: 	Ponteiro da estrutura do buffer
// Retorna: 	Primeiro caractere do buffer
//------------------------------------------------------------------------------------------------------------------
u8 buffer_GetFromFront(buffer_t *buffer) {
    31fa:	4603      	mov	r3, r0
	u8 data = 0;
	
	// check to see if there's data in the buffer
	if(buffer->datalength) {
    31fc:	88c0      	ldrh	r0, [r0, #6]
//------------------------------------------------------------------------------------------------------------------
// Descrição: 	Retorna com o primeiro caractere do buffer e retira-o do buffer
// Parametros: 	Ponteiro da estrutura do buffer
// Retorna: 	Primeiro caractere do buffer
//------------------------------------------------------------------------------------------------------------------
u8 buffer_GetFromFront(buffer_t *buffer) {
    31fe:	b510      	push	{r4, lr}
	u8 data = 0;
	
	// check to see if there's data in the buffer
	if(buffer->datalength) {
    3200:	b280      	uxth	r0, r0
    3202:	b1d8      	cbz	r0, 323c <buffer_GetFromFront+0x42>
		// get the first character from buffer
		data = buffer->dataptr[buffer->dataindex];
    3204:	6819      	ldr	r1, [r3, #0]
    3206:	891a      	ldrh	r2, [r3, #8]
    3208:	b292      	uxth	r2, r2
    320a:	5c88      	ldrb	r0, [r1, r2]
		// move index down and decrement length
		buffer->dataindex++;
    320c:	891a      	ldrh	r2, [r3, #8]
    320e:	3201      	adds	r2, #1
    3210:	b292      	uxth	r2, r2
    3212:	811a      	strh	r2, [r3, #8]
		if(buffer->dataindex >= buffer->size) {
    3214:	8919      	ldrh	r1, [r3, #8]
    3216:	889a      	ldrh	r2, [r3, #4]
    3218:	b289      	uxth	r1, r1
    321a:	b292      	uxth	r2, r2
    321c:	4291      	cmp	r1, r2
    321e:	d309      	bcc.n	3234 <buffer_GetFromFront+0x3a>
			buffer->dataindex %= buffer->size;
    3220:	889a      	ldrh	r2, [r3, #4]
    3222:	b294      	uxth	r4, r2
    3224:	891a      	ldrh	r2, [r3, #8]
    3226:	b292      	uxth	r2, r2
    3228:	fbb2 f1f4 	udiv	r1, r2, r4
    322c:	fb04 2211 	mls	r2, r4, r1, r2
    3230:	b292      	uxth	r2, r2
    3232:	811a      	strh	r2, [r3, #8]
		}
		buffer->datalength--;
    3234:	88da      	ldrh	r2, [r3, #6]
    3236:	3a01      	subs	r2, #1
    3238:	b292      	uxth	r2, r2
    323a:	80da      	strh	r2, [r3, #6]
	}
	
	return data;
}
    323c:	bd10      	pop	{r4, pc}

Disassembly of section .text.buffer_AddToEnd:

0000323e <buffer_AddToEnd>:
// Parametros: 	Ponteiro para estrutura do buffer e o dados a ser gravados
// Retorna: 	pdPASS se o dados for gravado com sucesso ou erro de acesso
//------------------------------------------------------------------------------------------------------------------
int buffer_AddToEnd(buffer_t* buffer, u8 data) {
	// make sure the buffer has room
	if(buffer->datalength < buffer->size) {
    323e:	88c2      	ldrh	r2, [r0, #6]
    3240:	8883      	ldrh	r3, [r0, #4]
    3242:	b292      	uxth	r2, r2
    3244:	b29b      	uxth	r3, r3
    3246:	429a      	cmp	r2, r3
//------------------------------------------------------------------------------------------------------------------
// Descrição: 	Adiciona o caractere no fim do buffer
// Parametros: 	Ponteiro para estrutura do buffer e o dados a ser gravados
// Retorna: 	pdPASS se o dados for gravado com sucesso ou erro de acesso
//------------------------------------------------------------------------------------------------------------------
int buffer_AddToEnd(buffer_t* buffer, u8 data) {
    3248:	b530      	push	{r4, r5, lr}
	// make sure the buffer has room
	if(buffer->datalength < buffer->size) {
    324a:	d212      	bcs.n	3272 <buffer_AddToEnd+0x34>
		// save data byte at end of buffer
		buffer->dataptr[(buffer->dataindex + buffer->datalength) % buffer->size] = data;
    324c:	6805      	ldr	r5, [r0, #0]
    324e:	8903      	ldrh	r3, [r0, #8]
    3250:	88c2      	ldrh	r2, [r0, #6]
    3252:	8884      	ldrh	r4, [r0, #4]
    3254:	b292      	uxth	r2, r2
    3256:	b29b      	uxth	r3, r3
    3258:	b2a4      	uxth	r4, r4
    325a:	4413      	add	r3, r2
    325c:	fb93 f2f4 	sdiv	r2, r3, r4
    3260:	fb04 3312 	mls	r3, r4, r2, r3
    3264:	54e9      	strb	r1, [r5, r3]
		// increment the length
		buffer->datalength++;
    3266:	88c3      	ldrh	r3, [r0, #6]
    3268:	3301      	adds	r3, #1
    326a:	b29b      	uxth	r3, r3
    326c:	80c3      	strh	r3, [r0, #6]
		// return success
		return pdPASS;
    326e:	2001      	movs	r0, #1
    3270:	bd30      	pop	{r4, r5, pc}
	} else 
		return errBUFFER_FULL;
    3272:	f06f 0009 	mvn.w	r0, #9
}
    3276:	bd30      	pop	{r4, r5, pc}

Disassembly of section .text.buffer_IsEmpty:

00003278 <buffer_IsEmpty>:
// Descrição: 	Verifica se o buffer esta vazio
// Parametros: 	Ponteiro para estrutura do buffer
// Retorna: 	Retorna pdTRUE se o buffer está vazio
//------------------------------------------------------------------------------------------------------------------
int buffer_IsEmpty(buffer_t *buffer) {
	if (buffer->datalength == 0)
    3278:	88c0      	ldrh	r0, [r0, #6]
    327a:	b280      	uxth	r0, r0
		return pdTRUE;
	else
		return pdFALSE;
}
    327c:	fab0 f080 	clz	r0, r0
    3280:	0940      	lsrs	r0, r0, #5
    3282:	4770      	bx	lr

Disassembly of section .text.put_dump16:

00003284 <put_dump16>:
// Retorna: 	Nada
//------------------------------------------------------------------------------------------------------------------
#ifdef CPU_AVR
void put_dump16 (const u8 *buff, u16 showAddrOffSet, int cnt, u8 mask ) {
#else
void put_dump16 (const u8 *buff, u32 showAddrOffSet, int cnt, u8 mask ) {
    3284:	b5f8      	push	{r3, r4, r5, r6, r7, lr}
    3286:	4606      	mov	r6, r0
    3288:	4615      	mov	r5, r2

	// IMPRIME O ENDEREÇO INICIAL (OFFSET)
	#ifdef CPU_AVR
	lprintf("%04x ", showAddrOffSet);
	#else
	lprintf("%08x ", showAddrOffSet);
    328a:	2001      	movs	r0, #1
    328c:	460a      	mov	r2, r1
    328e:	491b      	ldr	r1, [pc, #108]	; (32fc <put_dump16+0x78>)
// Retorna: 	Nada
//------------------------------------------------------------------------------------------------------------------
#ifdef CPU_AVR
void put_dump16 (const u8 *buff, u16 showAddrOffSet, int cnt, u8 mask ) {
#else
void put_dump16 (const u8 *buff, u32 showAddrOffSet, int cnt, u8 mask ) {
    3290:	461f      	mov	r7, r3

	// IMPRIME O ENDEREÇO INICIAL (OFFSET)
	#ifdef CPU_AVR
	lprintf("%04x ", showAddrOffSet);
	#else
	lprintf("%08x ", showAddrOffSet);
    3292:	f7ff ff97 	bl	31c4 <rprintf>
	#endif
	
	// IMPRIME HEXDECIMAL
	for(n=0; n<cnt; n++) lprintf(" %02x", buff[n]);
    3296:	2300      	movs	r3, #0
    3298:	1c5c      	adds	r4, r3, #1
    329a:	b2db      	uxtb	r3, r3
    329c:	42ab      	cmp	r3, r5
    329e:	da06      	bge.n	32ae <put_dump16+0x2a>
    32a0:	5cf2      	ldrb	r2, [r6, r3]
    32a2:	4917      	ldr	r1, [pc, #92]	; (3300 <put_dump16+0x7c>)
    32a4:	2001      	movs	r0, #1
    32a6:	f7ff ff8d 	bl	31c4 <rprintf>
    32aa:	4623      	mov	r3, r4
    32ac:	e7f4      	b.n	3298 <put_dump16+0x14>
		
	// CASO A QUANTIDADE DE BYTES DA LINHA NÃO SEJA O TAMANHO DA MASK
	// Isto preenche a coluna hex com espaços para que a coluna dos caracteres se alinhe com as impressões anteriores
	for(n=cnt; n<mask; n++)	lprintf("   ");
    32ae:	b2ec      	uxtb	r4, r5
    32b0:	42bc      	cmp	r4, r7
    32b2:	d206      	bcs.n	32c2 <put_dump16+0x3e>
    32b4:	4913      	ldr	r1, [pc, #76]	; (3304 <put_dump16+0x80>)
    32b6:	2001      	movs	r0, #1
    32b8:	3401      	adds	r4, #1
    32ba:	f7ff ff83 	bl	31c4 <rprintf>
    32be:	b2e4      	uxtb	r4, r4
    32c0:	e7f6      	b.n	32b0 <put_dump16+0x2c>
	
	// IMPRIME SEPARADOR
	lprintf(" : ");
    32c2:	4911      	ldr	r1, [pc, #68]	; (3308 <put_dump16+0x84>)
    32c4:	2001      	movs	r0, #1
    32c6:	f7ff ff7d 	bl	31c4 <rprintf>
	
	// IMPRIME CHAR
	for(n = 0; n < cnt; n++) {
    32ca:	2400      	movs	r4, #0
    32cc:	b2e3      	uxtb	r3, r4
    32ce:	429d      	cmp	r5, r3
    32d0:	dd0d      	ble.n	32ee <put_dump16+0x6a>
		//if ((buff[n] < 0x20)||(buff[n] >= 0x7F))
		if ( buff[n] < 0x20 )	lprintf(".");
    32d2:	5cf2      	ldrb	r2, [r6, r3]
    32d4:	2a1f      	cmp	r2, #31
    32d6:	d804      	bhi.n	32e2 <put_dump16+0x5e>
    32d8:	490c      	ldr	r1, [pc, #48]	; (330c <put_dump16+0x88>)
    32da:	2001      	movs	r0, #1
    32dc:	f7ff ff72 	bl	31c4 <rprintf>
    32e0:	e003      	b.n	32ea <put_dump16+0x66>
		else					lprintf("%c", buff[n]);
    32e2:	490b      	ldr	r1, [pc, #44]	; (3310 <put_dump16+0x8c>)
    32e4:	2001      	movs	r0, #1
    32e6:	f7ff ff6d 	bl	31c4 <rprintf>
    32ea:	3401      	adds	r4, #1
    32ec:	e7ee      	b.n	32cc <put_dump16+0x48>
	}
	
	lprintf(CMD_TERMINATOR);
    32ee:	4909      	ldr	r1, [pc, #36]	; (3314 <put_dump16+0x90>)
    32f0:	2001      	movs	r0, #1
}
    32f2:	e8bd 40f8 	ldmia.w	sp!, {r3, r4, r5, r6, r7, lr}
		//if ((buff[n] < 0x20)||(buff[n] >= 0x7F))
		if ( buff[n] < 0x20 )	lprintf(".");
		else					lprintf("%c", buff[n]);
	}
	
	lprintf(CMD_TERMINATOR);
    32f6:	f7ff bf65 	b.w	31c4 <rprintf>
    32fa:	bf00      	nop
    32fc:	0000a610 	.word	0x0000a610
    3300:	0000a616 	.word	0x0000a616
    3304:	0000a61c 	.word	0x0000a61c
    3308:	0000a620 	.word	0x0000a620
    330c:	0000a60b 	.word	0x0000a60b
    3310:	0000a60d 	.word	0x0000a60d
    3314:	000059ed 	.word	0x000059ed

Disassembly of section .text.xatoi:

00003318 <xatoi>:
//				Exemplos: "0x10" ret 16. 	"-100" ret -100. 	"0b1100" ret 12
// Parametros: 	Endereço da string para ser convertida e o endereço da var inteira par retorno da conversão
// Retorna: 	pdTRUE se houve conversão ou pdFALSE caso não foi possivel converter
//------------------------------------------------------------------------------------------------------------------
// Converte ASCII para Integer
int xatoi (char **str, long *res) {
    3318:	b570      	push	{r4, r5, r6, lr}
	u32 val;
	u8 c, radix, s = 0;


	while ((c = **str) == ' ') (*str)++;
    331a:	6802      	ldr	r2, [r0, #0]
    331c:	7813      	ldrb	r3, [r2, #0]
    331e:	2b20      	cmp	r3, #32
    3320:	d102      	bne.n	3328 <xatoi+0x10>
    3322:	3201      	adds	r2, #1
    3324:	6002      	str	r2, [r0, #0]
    3326:	e7f8      	b.n	331a <xatoi+0x2>
	if (c == '-') {
    3328:	2b2d      	cmp	r3, #45	; 0x2d
		s = 1;
		c = *(++(*str));
    332a:	bf01      	itttt	eq
    332c:	1c53      	addeq	r3, r2, #1
    332e:	6003      	streq	r3, [r0, #0]
    3330:	7853      	ldrbeq	r3, [r2, #1]
	u8 c, radix, s = 0;


	while ((c = **str) == ' ') (*str)++;
	if (c == '-') {
		s = 1;
    3332:	2601      	moveq	r6, #1
// Retorna: 	pdTRUE se houve conversão ou pdFALSE caso não foi possivel converter
//------------------------------------------------------------------------------------------------------------------
// Converte ASCII para Integer
int xatoi (char **str, long *res) {
	u32 val;
	u8 c, radix, s = 0;
    3334:	bf18      	it	ne
    3336:	2600      	movne	r6, #0
	if (c == '-') {
		s = 1;
		c = *(++(*str));
	}
	
	if (c == '0') {
    3338:	2b30      	cmp	r3, #48	; 0x30
    333a:	d11c      	bne.n	3376 <xatoi+0x5e>
		c = *(++(*str));
    333c:	6802      	ldr	r2, [r0, #0]
    333e:	1c53      	adds	r3, r2, #1
    3340:	6003      	str	r3, [r0, #0]
    3342:	7853      	ldrb	r3, [r2, #1]
		if (c <= ' ') {
    3344:	2b20      	cmp	r3, #32
    3346:	d802      	bhi.n	334e <xatoi+0x36>
			*res = 0; return pdTRUE;
    3348:	2300      	movs	r3, #0
    334a:	600b      	str	r3, [r1, #0]
    334c:	e036      	b.n	33bc <xatoi+0xa4>
		}
		if (c == 'x') {
    334e:	2b78      	cmp	r3, #120	; 0x78
    3350:	d104      	bne.n	335c <xatoi+0x44>
			radix = 16;
			c = *(++(*str));
    3352:	1c93      	adds	r3, r2, #2
    3354:	6003      	str	r3, [r0, #0]
    3356:	7893      	ldrb	r3, [r2, #2]
		c = *(++(*str));
		if (c <= ' ') {
			*res = 0; return pdTRUE;
		}
		if (c == 'x') {
			radix = 16;
    3358:	2510      	movs	r5, #16
    335a:	e013      	b.n	3384 <xatoi+0x6c>
			c = *(++(*str));
		} else {
			if (c == 'b') {
    335c:	2b62      	cmp	r3, #98	; 0x62
    335e:	d104      	bne.n	336a <xatoi+0x52>
				radix = 2;
				c = *(++(*str));
    3360:	1c93      	adds	r3, r2, #2
    3362:	6003      	str	r3, [r0, #0]
    3364:	7893      	ldrb	r3, [r2, #2]
		if (c == 'x') {
			radix = 16;
			c = *(++(*str));
		} else {
			if (c == 'b') {
				radix = 2;
    3366:	2502      	movs	r5, #2
    3368:	e00c      	b.n	3384 <xatoi+0x6c>
				c = *(++(*str));
			} else {
				if ((c >= '0')&&(c <= '9'))
    336a:	f1a3 0230 	sub.w	r2, r3, #48	; 0x30
    336e:	2a09      	cmp	r2, #9
    3370:	d907      	bls.n	3382 <xatoi+0x6a>
					radix = 8;
				else
					return pdFALSE;
    3372:	2000      	movs	r0, #0
    3374:	bd70      	pop	{r4, r5, r6, pc}
			}
		}
	} else {
		if ((c < '1')||(c > '9'))
    3376:	f1a3 0231 	sub.w	r2, r3, #49	; 0x31
    337a:	2a08      	cmp	r2, #8
    337c:	d8f9      	bhi.n	3372 <xatoi+0x5a>
			return pdFALSE;
		radix = 10;
    337e:	250a      	movs	r5, #10
    3380:	e000      	b.n	3384 <xatoi+0x6c>
			if (c == 'b') {
				radix = 2;
				c = *(++(*str));
			} else {
				if ((c >= '0')&&(c <= '9'))
					radix = 8;
    3382:	2508      	movs	r5, #8
	} else {
		if ((c < '1')||(c > '9'))
			return pdFALSE;
		radix = 10;
	}
	val = 0;
    3384:	2400      	movs	r4, #0
	while (c > ' ') {
    3386:	2b20      	cmp	r3, #32
    3388:	d915      	bls.n	33b6 <xatoi+0x9e>
		if (c >= 'a') c -= 0x20;
    338a:	2b60      	cmp	r3, #96	; 0x60
    338c:	bf84      	itt	hi
    338e:	3b20      	subhi	r3, #32
    3390:	b2db      	uxtbhi	r3, r3
		c -= '0';
    3392:	f1a3 0230 	sub.w	r2, r3, #48	; 0x30
    3396:	b2d2      	uxtb	r2, r2
		if (c >= 17) {
    3398:	2a10      	cmp	r2, #16
    339a:	d903      	bls.n	33a4 <xatoi+0x8c>
			c -= 7;
    339c:	3b37      	subs	r3, #55	; 0x37
    339e:	b2da      	uxtb	r2, r3
			if (c <= 9) return pdFALSE;
    33a0:	2a09      	cmp	r2, #9
    33a2:	d9e6      	bls.n	3372 <xatoi+0x5a>
		}
		if (c >= radix) return pdFALSE;
    33a4:	42aa      	cmp	r2, r5
    33a6:	d2e4      	bcs.n	3372 <xatoi+0x5a>
		val = val * radix + c;
		c = *(++(*str));
    33a8:	6803      	ldr	r3, [r0, #0]
		if (c >= 17) {
			c -= 7;
			if (c <= 9) return pdFALSE;
		}
		if (c >= radix) return pdFALSE;
		val = val * radix + c;
    33aa:	fb04 2405 	mla	r4, r4, r5, r2
		c = *(++(*str));
    33ae:	1c5a      	adds	r2, r3, #1
    33b0:	6002      	str	r2, [r0, #0]
    33b2:	785b      	ldrb	r3, [r3, #1]
    33b4:	e7e7      	b.n	3386 <xatoi+0x6e>
	}
	if (s) val = -val;
    33b6:	b106      	cbz	r6, 33ba <xatoi+0xa2>
    33b8:	4264      	negs	r4, r4
	*res = val;
    33ba:	600c      	str	r4, [r1, #0]
	return pdTRUE;
    33bc:	2001      	movs	r0, #1
}
    33be:	bd70      	pop	{r4, r5, r6, pc}

Disassembly of section .text.ledError_Init:

000033c0 <ledError_Init>:
static void led_SetupPorts(void);
static void led_State(int st);

#if defined(CPU_ARM_LPC)
static void led_SetupPorts(void) {
	ledERROR_DIR |= ledERROR;
    33c0:	4a04      	ldr	r2, [pc, #16]	; (33d4 <ledError_Init+0x14>)
    33c2:	6813      	ldr	r3, [r2, #0]
    33c4:	f043 5300 	orr.w	r3, r3, #536870912	; 0x20000000
    33c8:	6013      	str	r3, [r2, #0]
	ledERROR_OFF |= ledERROR;
    33ca:	69d3      	ldr	r3, [r2, #28]
    33cc:	f043 5300 	orr.w	r3, r3, #536870912	; 0x20000000
    33d0:	61d3      	str	r3, [r2, #28]
    33d2:	4770      	bx	lr
    33d4:	2009c080 	.word	0x2009c080

Disassembly of section .text.ledError_Tick:

000033d8 <ledError_Tick>:


// função de sistema para ser chamado a cada 1ms
// o numero do erro representa a quantidade de vezes que led vai piscar. Se for valor 0 deixa o led apagado
void ledError_Tick(void) {
	if (!ledBlink) return;
    33d8:	4b1b      	ldr	r3, [pc, #108]	; (3448 <ledError_Tick+0x70>)
}


// função de sistema para ser chamado a cada 1ms
// o numero do erro representa a quantidade de vezes que led vai piscar. Se for valor 0 deixa o led apagado
void ledError_Tick(void) {
    33da:	b570      	push	{r4, r5, r6, lr}
	if (!ledBlink) return;
    33dc:	681b      	ldr	r3, [r3, #0]
    33de:	2b00      	cmp	r3, #0
    33e0:	d031      	beq.n	3446 <ledError_Tick+0x6e>
	static int count1 = 0;
	static int count2 = 0;
	static int ff = 0;
	static int nTimes = 0;

	if (count1==0) {
    33e2:	4a1a      	ldr	r2, [pc, #104]	; (344c <ledError_Tick+0x74>)
    33e4:	6813      	ldr	r3, [r2, #0]
    33e6:	2b00      	cmp	r3, #0
    33e8:	d12b      	bne.n	3442 <ledError_Tick+0x6a>
		if (count2==0) { // Prepara o intervalo entre as piscadas do led
    33ea:	4b19      	ldr	r3, [pc, #100]	; (3450 <ledError_Tick+0x78>)
    33ec:	4c19      	ldr	r4, [pc, #100]	; (3454 <ledError_Tick+0x7c>)
    33ee:	6819      	ldr	r1, [r3, #0]
    33f0:	b931      	cbnz	r1, 3400 <ledError_Tick+0x28>
			count2 = 1000;
    33f2:	f44f 717a 	mov.w	r1, #1000	; 0x3e8
    33f6:	6019      	str	r1, [r3, #0]
			nTimes = 2*(error);
    33f8:	4917      	ldr	r1, [pc, #92]	; (3458 <ledError_Tick+0x80>)
    33fa:	6809      	ldr	r1, [r1, #0]
    33fc:	0049      	lsls	r1, r1, #1
    33fe:	6021      	str	r1, [r4, #0]
		}

		if (nTimes>0) { // Pisca o led por 250 ms vezes nTimes
    3400:	6821      	ldr	r1, [r4, #0]
    3402:	2900      	cmp	r1, #0
    3404:	dd11      	ble.n	342a <ledError_Tick+0x52>
			if (ff)	led_State(pdOFF); else led_State(pdON);
    3406:	4b15      	ldr	r3, [pc, #84]	; (345c <ledError_Tick+0x84>)
    3408:	6818      	ldr	r0, [r3, #0]
    340a:	b108      	cbz	r0, 3410 <ledError_Tick+0x38>
	ledERROR_DIR |= ledERROR;
	ledERROR_OFF |= ledERROR;
}

static void led_State(int st) {
	if (st == pdON) ledERROR_ON |= ledERROR; else ledERROR_OFF |= ledERROR;
    340c:	4e14      	ldr	r6, [pc, #80]	; (3460 <ledError_Tick+0x88>)
    340e:	e000      	b.n	3412 <ledError_Tick+0x3a>
    3410:	4e14      	ldr	r6, [pc, #80]	; (3464 <ledError_Tick+0x8c>)
    3412:	6835      	ldr	r5, [r6, #0]
		}

		if (nTimes>0) { // Pisca o led por 250 ms vezes nTimes
			if (ff)	led_State(pdOFF); else led_State(pdON);
			count1 = 250;
			ff ^= 1;
    3414:	f080 0001 	eor.w	r0, r0, #1
	ledERROR_DIR |= ledERROR;
	ledERROR_OFF |= ledERROR;
}

static void led_State(int st) {
	if (st == pdON) ledERROR_ON |= ledERROR; else ledERROR_OFF |= ledERROR;
    3418:	f045 5500 	orr.w	r5, r5, #536870912	; 0x20000000
    341c:	6035      	str	r5, [r6, #0]

		if (nTimes>0) { // Pisca o led por 250 ms vezes nTimes
			if (ff)	led_State(pdOFF); else led_State(pdON);
			count1 = 250;
			ff ^= 1;
			nTimes--;
    341e:	3901      	subs	r1, #1
			nTimes = 2*(error);
		}

		if (nTimes>0) { // Pisca o led por 250 ms vezes nTimes
			if (ff)	led_State(pdOFF); else led_State(pdON);
			count1 = 250;
    3420:	25fa      	movs	r5, #250	; 0xfa
    3422:	6015      	str	r5, [r2, #0]
			ff ^= 1;
    3424:	6018      	str	r0, [r3, #0]
			nTimes--;
    3426:	6021      	str	r1, [r4, #0]
    3428:	e009      	b.n	343e <ledError_Tick+0x66>
	ledERROR_DIR |= ledERROR;
	ledERROR_OFF |= ledERROR;
}

static void led_State(int st) {
	if (st == pdON) ledERROR_ON |= ledERROR; else ledERROR_OFF |= ledERROR;
    342a:	480d      	ldr	r0, [pc, #52]	; (3460 <ledError_Tick+0x88>)
			count1 = 250;
			ff ^= 1;
			nTimes--;
		} else { // Mantém o led apagado por 1 segundo
			led_State(pdOFF);
			if (count2) count2--;
    342c:	681b      	ldr	r3, [r3, #0]
	ledERROR_DIR |= ledERROR;
	ledERROR_OFF |= ledERROR;
}

static void led_State(int st) {
	if (st == pdON) ledERROR_ON |= ledERROR; else ledERROR_OFF |= ledERROR;
    342e:	6801      	ldr	r1, [r0, #0]
    3430:	f041 5100 	orr.w	r1, r1, #536870912	; 0x20000000
    3434:	6001      	str	r1, [r0, #0]
			count1 = 250;
			ff ^= 1;
			nTimes--;
		} else { // Mantém o led apagado por 1 segundo
			led_State(pdOFF);
			if (count2) count2--;
    3436:	b133      	cbz	r3, 3446 <ledError_Tick+0x6e>
    3438:	4905      	ldr	r1, [pc, #20]	; (3450 <ledError_Tick+0x78>)
    343a:	3b01      	subs	r3, #1
    343c:	600b      	str	r3, [r1, #0]
		}
	}

	if (count1) count1--;
    343e:	6813      	ldr	r3, [r2, #0]
    3440:	b10b      	cbz	r3, 3446 <ledError_Tick+0x6e>
    3442:	3b01      	subs	r3, #1
    3444:	6013      	str	r3, [r2, #0]
    3446:	bd70      	pop	{r4, r5, r6, pc}
    3448:	100007f8 	.word	0x100007f8
    344c:	100007f0 	.word	0x100007f0
    3450:	10000800 	.word	0x10000800
    3454:	10000804 	.word	0x10000804
    3458:	100007f4 	.word	0x100007f4
    345c:	100007fc 	.word	0x100007fc
    3460:	2009c09c 	.word	0x2009c09c
    3464:	2009c098 	.word	0x2009c098

Disassembly of section .text.gKey_Init:

00003468 <gKey_Init>:
		// se desejar processar a tecla quando a mesma for pressionada, durante o pressionamento
		//		e quando soltar a tecla
//		gkey_Init(NULL, NULL, &onKeyUp);
		// se desejar processar a tecla somente a mesma for solta
void gKey_Init(pkeyFunc onKdown, pkeyFunc onKpress, pkeyFunc onKup) {
	onKeyDown = onKdown;
    3468:	4b04      	ldr	r3, [pc, #16]	; (347c <gKey_Init+0x14>)
    346a:	6018      	str	r0, [r3, #0]
	onKeyPress = onKpress;
    346c:	4b04      	ldr	r3, [pc, #16]	; (3480 <gKey_Init+0x18>)
    346e:	6019      	str	r1, [r3, #0]
	onKeyUp = onKup;
    3470:	4b04      	ldr	r3, [pc, #16]	; (3484 <gKey_Init+0x1c>)
    3472:	601a      	str	r2, [r3, #0]
	gkey_FastInc = 0; // sem repetição
    3474:	4b04      	ldr	r3, [pc, #16]	; (3488 <gKey_Init+0x20>)
    3476:	2200      	movs	r2, #0
    3478:	601a      	str	r2, [r3, #0]
    347a:	4770      	bx	lr
    347c:	1000081c 	.word	0x1000081c
    3480:	10000820 	.word	0x10000820
    3484:	10000810 	.word	0x10000810
    3488:	100005f4 	.word	0x100005f4

Disassembly of section .text.gKey_Tick:

0000348c <gKey_Tick>:


// função a ser chamada a cada 1ms
static volatile uint timeRepeat=0;
void gKey_Tick(void) {
	if (timeRepeat) timeRepeat--;
    348c:	4b03      	ldr	r3, [pc, #12]	; (349c <gKey_Tick+0x10>)
    348e:	681a      	ldr	r2, [r3, #0]
    3490:	b112      	cbz	r2, 3498 <gKey_Tick+0xc>
    3492:	681a      	ldr	r2, [r3, #0]
    3494:	3a01      	subs	r2, #1
    3496:	601a      	str	r2, [r3, #0]
    3498:	4770      	bx	lr
    349a:	bf00      	nop
    349c:	10000814 	.word	0x10000814

Disassembly of section .text.gKey_Process:

000034a0 <gKey_Process>:

// Gerador de enventos para tecla pressioada
// A função gKey_Process vai chamar as funções anexadas em onKdown, onKpress, onKup em gKey_Init
// passando o valor da tecla pressionada. São nessas funções que iremos processar a tecla
// ATENÇÃO: Tecla pressionada deve ter valor > 0. Nenhuma tecla pressionada deve retornar valor 0
void gKey_Process(char key) {
    34a0:	b570      	push	{r4, r5, r6, lr}
    static char keyold=0, keynow=0, estado=0;
    static uint repeat=0;

    //verificação da tecla
    keyold = keynow;
    34a2:	4a21      	ldr	r2, [pc, #132]	; (3528 <gKey_Process+0x88>)
    keynow = key;

    //repetição rapida?
    //gkey_FastInc = repeat==0;					// Sinaliza se é para incrementar/decrementar mais rápido quando a tecle permanecer pressionada

    switch (estado) {
    34a4:	4d21      	ldr	r5, [pc, #132]	; (352c <gKey_Process+0x8c>)
void gKey_Process(char key) {
    static char keyold=0, keynow=0, estado=0;
    static uint repeat=0;

    //verificação da tecla
    keyold = keynow;
    34a6:	7813      	ldrb	r3, [r2, #0]
    keynow = key;
    34a8:	7010      	strb	r0, [r2, #0]

    //repetição rapida?
    //gkey_FastInc = repeat==0;					// Sinaliza se é para incrementar/decrementar mais rápido quando a tecle permanecer pressionada

    switch (estado) {
    34aa:	782a      	ldrb	r2, [r5, #0]

// Gerador de enventos para tecla pressioada
// A função gKey_Process vai chamar as funções anexadas em onKdown, onKpress, onKup em gKey_Init
// passando o valor da tecla pressionada. São nessas funções que iremos processar a tecla
// ATENÇÃO: Tecla pressionada deve ter valor > 0. Nenhuma tecla pressionada deve retornar valor 0
void gKey_Process(char key) {
    34ac:	4604      	mov	r4, r0
    keynow = key;

    //repetição rapida?
    //gkey_FastInc = repeat==0;					// Sinaliza se é para incrementar/decrementar mais rápido quando a tecle permanecer pressionada

    switch (estado) {
    34ae:	b112      	cbz	r2, 34b6 <gKey_Process+0x16>
    34b0:	2a01      	cmp	r2, #1
    34b2:	d018      	beq.n	34e6 <gKey_Process+0x46>
    34b4:	bd70      	pop	{r4, r5, r6, pc}
    case 0: 									// Estado de verificação se tecla foi pressionada
    	repeat = keyREPEAT;						// A cada X segundos incrementos o gkey_FastInc
    34b6:	491e      	ldr	r1, [pc, #120]	; (3530 <gKey_Process+0x90>)
    34b8:	260a      	movs	r6, #10
    34ba:	600e      	str	r6, [r1, #0]
		gkey_FastInc = 0;						// Sinaliza para não incrementar de modo rápido
    34bc:	491d      	ldr	r1, [pc, #116]	; (3534 <gKey_Process+0x94>)
    34be:	600a      	str	r2, [r1, #0]
    	if ((keyold==0)&&(keynow!=0)) {			// Checa se é a descida da tecla, se sim emitir o evento onKeyDown e onKeyPress
    34c0:	2b00      	cmp	r3, #0
    34c2:	d12f      	bne.n	3524 <gKey_Process+0x84>
    34c4:	2800      	cmp	r0, #0
    34c6:	d02d      	beq.n	3524 <gKey_Process+0x84>
            if (onKeyDown) onKeyDown(key);		// Emitir o evento onKeyDown e onKeyPress
    34c8:	4b1b      	ldr	r3, [pc, #108]	; (3538 <gKey_Process+0x98>)
    34ca:	681b      	ldr	r3, [r3, #0]
    34cc:	b103      	cbz	r3, 34d0 <gKey_Process+0x30>
    34ce:	4798      	blx	r3
            if (onKeyPress) onKeyPress(key);	// Emitir o evento onKeyPress
    34d0:	4b1a      	ldr	r3, [pc, #104]	; (353c <gKey_Process+0x9c>)
    34d2:	681b      	ldr	r3, [r3, #0]
    34d4:	b10b      	cbz	r3, 34da <gKey_Process+0x3a>
    34d6:	4620      	mov	r0, r4
    34d8:	4798      	blx	r3
            timeRepeat = keyKEYPRESS_REPEAT1;	// Determina em que tempo vamos repetir o evento onKeyPress após a primeira vez
    34da:	4b19      	ldr	r3, [pc, #100]	; (3540 <gKey_Process+0xa0>)
    34dc:	f44f 72fa 	mov.w	r2, #500	; 0x1f4
    34e0:	601a      	str	r2, [r3, #0]
    		estado = 1;							// Vá para o estado de verificação de tecla precionada
    34e2:	2301      	movs	r3, #1
    34e4:	e007      	b.n	34f6 <gKey_Process+0x56>
    	}
    	break;
    case 1: 									// Estado de verificação se a tecla esta sendo pressionada ou tecla foi solta
    	if ((keyold!=0)&&(keynow==0)) {			// Checa se é a subida da tecla, se sim emitir o evento onKeyUp
    34e6:	b143      	cbz	r3, 34fa <gKey_Process+0x5a>
    34e8:	b938      	cbnz	r0, 34fa <gKey_Process+0x5a>
    		if (onKeyUp) onKeyUp(keyold);
    34ea:	4a16      	ldr	r2, [pc, #88]	; (3544 <gKey_Process+0xa4>)
    34ec:	6812      	ldr	r2, [r2, #0]
    34ee:	b10a      	cbz	r2, 34f4 <gKey_Process+0x54>
    34f0:	4618      	mov	r0, r3
    34f2:	4790      	blx	r2
    		estado = 0;							// Volta ao estado para esperar a próxima tecla a ser pressionada
    34f4:	2300      	movs	r3, #0
    34f6:	702b      	strb	r3, [r5, #0]
    34f8:	bd70      	pop	{r4, r5, r6, pc}
    	} else if (timeRepeat == 0) {					// Checa se está na hora de repetir o evento onKeyPress
    34fa:	4b11      	ldr	r3, [pc, #68]	; (3540 <gKey_Process+0xa0>)
    34fc:	681a      	ldr	r2, [r3, #0]
    34fe:	b98a      	cbnz	r2, 3524 <gKey_Process+0x84>
            timeRepeat = keyKEYPRESS_REPEAT2; 		// Determina em que tempo vamos repetir o evento onKeyPress sucessivamente quando a tecla for mantida pressionada
    3500:	2264      	movs	r2, #100	; 0x64
    3502:	601a      	str	r2, [r3, #0]
            if (onKeyPress) onKeyPress(key);	// Chama o evento onKeyPress
    3504:	4b0d      	ldr	r3, [pc, #52]	; (353c <gKey_Process+0x9c>)
    3506:	681b      	ldr	r3, [r3, #0]
    3508:	b10b      	cbz	r3, 350e <gKey_Process+0x6e>
    350a:	4620      	mov	r0, r4
    350c:	4798      	blx	r3

            // checar o momento de incrementar a var FastInc
            if (repeat) repeat--;
    350e:	4a08      	ldr	r2, [pc, #32]	; (3530 <gKey_Process+0x90>)
    3510:	6813      	ldr	r3, [r2, #0]
    3512:	b10b      	cbz	r3, 3518 <gKey_Process+0x78>
    3514:	3b01      	subs	r3, #1
    3516:	e004      	b.n	3522 <gKey_Process+0x82>
            else {
            	repeat = keyREPEAT;
    3518:	230a      	movs	r3, #10
    351a:	6013      	str	r3, [r2, #0]
            	gkey_FastInc++;
    351c:	4a05      	ldr	r2, [pc, #20]	; (3534 <gKey_Process+0x94>)
    351e:	6813      	ldr	r3, [r2, #0]
    3520:	3301      	adds	r3, #1
    3522:	6013      	str	r3, [r2, #0]
    3524:	bd70      	pop	{r4, r5, r6, pc}
    3526:	bf00      	nop
    3528:	10000818 	.word	0x10000818
    352c:	1000080c 	.word	0x1000080c
    3530:	10000808 	.word	0x10000808
    3534:	100005f4 	.word	0x100005f4
    3538:	1000081c 	.word	0x1000081c
    353c:	10000820 	.word	0x10000820
    3540:	10000814 	.word	0x10000814
    3544:	10000810 	.word	0x10000810

Disassembly of section .text.beep_SetType:

00003548 <beep_SetType>:

// -------------------------------------------------------------------------------------------------------------------
// Descrição:	Ajusta o controlador a emitir o tipo sonoro
// -------------------------------------------------------------------------------------------------------------------
static void beep_SetType(void) {
	uint x; for(x=0;x<nPULSE_BEEPS;x++) { beep.pulse[x].tOff = 0; beep.pulse[x].tOn = 0;}
    3548:	4b20      	ldr	r3, [pc, #128]	; (35cc <beep_SetType+0x84>)
    354a:	2200      	movs	r2, #0
    354c:	615a      	str	r2, [r3, #20]
    354e:	611a      	str	r2, [r3, #16]
    3550:	61da      	str	r2, [r3, #28]
    3552:	619a      	str	r2, [r3, #24]
    3554:	625a      	str	r2, [r3, #36]	; 0x24
    3556:	621a      	str	r2, [r3, #32]
	beep.index = 0;
    3558:	60da      	str	r2, [r3, #12]
	beep.interval = 0;
    355a:	62da      	str	r2, [r3, #44]	; 0x2c

	switch(beep.type) {
    355c:	685a      	ldr	r2, [r3, #4]
    355e:	3a02      	subs	r2, #2
    3560:	2a04      	cmp	r2, #4
    3562:	d832      	bhi.n	35ca <beep_SetType+0x82>
    3564:	e8df f002 	tbb	[pc, r2]
    3568:	1b090313 	.word	0x1b090313
    356c:	25          	.byte	0x25
    356d:	00          	.byte	0x00
	case beep1SHORTBEEP:
 		beep.nBeeps = 1; // Emitir 1 beep
    356e:	2201      	movs	r2, #1
    3570:	609a      	str	r2, [r3, #8]
 		beep.pulse[0].tOn = 50; // Primeiro beep 50 ms ligado
    3572:	2232      	movs	r2, #50	; 0x32
    3574:	611a      	str	r2, [r3, #16]
 		beep.pulse[0].tOff = 50; // Primeiro beep 50 ms desligado
    3576:	615a      	str	r2, [r3, #20]
    3578:	e025      	b.n	35c6 <beep_SetType+0x7e>
 		beep.intervalLoad = 0; // sem repetições
		break;
	case beep3SHORTBEEP:
		beep.nBeeps = 3; // Emitir 3 beeps
    357a:	2203      	movs	r2, #3
    357c:	609a      	str	r2, [r3, #8]
		for(x=0;x<3;x++) { beep.pulse[x].tOff = 50; beep.pulse[x].tOn = 50;} // todos os beeps 50ms ligado e desligado
    357e:	2232      	movs	r2, #50	; 0x32
    3580:	615a      	str	r2, [r3, #20]
    3582:	611a      	str	r2, [r3, #16]
    3584:	61da      	str	r2, [r3, #28]
    3586:	619a      	str	r2, [r3, #24]
    3588:	625a      	str	r2, [r3, #36]	; 0x24
    358a:	621a      	str	r2, [r3, #32]
    358c:	e01b      	b.n	35c6 <beep_SetType+0x7e>
		beep.intervalLoad = 0; // sem repetições
		break;
	case beepCONTINUOUS_ONOFF:
 		beep.nBeeps = 1; // Emitir 1 beep
    358e:	2201      	movs	r2, #1
    3590:	609a      	str	r2, [r3, #8]
 		beep.pulse[0].tOn = 100; // Primeiro beep 100 ms ligado
 		beep.pulse[0].tOff = 800; // Primeiro beep 800 ms desligado
    3592:	f44f 7148 	mov.w	r1, #800	; 0x320
		for(x=0;x<3;x++) { beep.pulse[x].tOff = 50; beep.pulse[x].tOn = 50;} // todos os beeps 50ms ligado e desligado
		beep.intervalLoad = 0; // sem repetições
		break;
	case beepCONTINUOUS_ONOFF:
 		beep.nBeeps = 1; // Emitir 1 beep
 		beep.pulse[0].tOn = 100; // Primeiro beep 100 ms ligado
    3596:	2264      	movs	r2, #100	; 0x64
    3598:	611a      	str	r2, [r3, #16]
 		beep.pulse[0].tOff = 800; // Primeiro beep 800 ms desligado
    359a:	6159      	str	r1, [r3, #20]
    359c:	e014      	b.n	35c8 <beep_SetType+0x80>
 		beep.intervalLoad = 100; // repetir os beeps a cada 100ms
		break;
	case beepCONTINUOUS_2xONOFF:
		beep.nBeeps = 2; // Emitir 2 beeps
    359e:	2202      	movs	r2, #2
    35a0:	609a      	str	r2, [r3, #8]
		beep.pulse[0].tOn = 100; // Primeiro beep 100 ms ligado
    35a2:	2264      	movs	r2, #100	; 0x64
    35a4:	611a      	str	r2, [r3, #16]
 		beep.pulse[0].tOff = 100; // Primeiro beep 100 ms desligado
    35a6:	615a      	str	r2, [r3, #20]
 		beep.pulse[1].tOn = 100; // Segundo beep 100 ms ligado
    35a8:	619a      	str	r2, [r3, #24]
 		beep.pulse[1].tOff = 100; // Segundo beep 100 ms desligado
    35aa:	61da      	str	r2, [r3, #28]
 		beep.intervalLoad = 2000; // repetir os beeps a cada 2000ms
    35ac:	f44f 62fa 	mov.w	r2, #2000	; 0x7d0
    35b0:	e00a      	b.n	35c8 <beep_SetType+0x80>
		break;
	case beep1LONG2SHORTBEEP:
		beep.nBeeps = 3; // Emitir 3 beeps
    35b2:	2203      	movs	r2, #3
    35b4:	609a      	str	r2, [r3, #8]

 		beep.pulse[0].tOn = 100; // Primeiro beep 100 ms ligado
    35b6:	2264      	movs	r2, #100	; 0x64
    35b8:	611a      	str	r2, [r3, #16]
 		beep.pulse[0].tOff = 100; // Primeiro beep 100 ms desligado
    35ba:	615a      	str	r2, [r3, #20]
 		beep.pulse[1].tOn = 50; // Segundo beep 50 ms ligado
    35bc:	2232      	movs	r2, #50	; 0x32
    35be:	619a      	str	r2, [r3, #24]
 		beep.pulse[1].tOff = 50; // Segundo beep 50 ms desligado
    35c0:	61da      	str	r2, [r3, #28]
 		beep.pulse[2].tOn = 50; // Terceiro beep 50 ms ligado
    35c2:	621a      	str	r2, [r3, #32]
 		beep.pulse[2].tOff = 50; // Terceiro beep 50 ms desligado
    35c4:	625a      	str	r2, [r3, #36]	; 0x24
		beep.intervalLoad = 0; // sem repetições
    35c6:	2200      	movs	r2, #0
    35c8:	629a      	str	r2, [r3, #40]	; 0x28
    35ca:	4770      	bx	lr
    35cc:	10000824 	.word	0x10000824

Disassembly of section .text.beep_Init:

000035d0 <beep_Init>:

// -------------------------------------------------------------------------------------------------------------------
// Descrição:	Inicializa o gerenciador de beeps
// -------------------------------------------------------------------------------------------------------------------
void beep_Init(void) {
	beep_SetupPorts();
    35d0:	4a07      	ldr	r2, [pc, #28]	; (35f0 <beep_Init+0x20>)
    35d2:	6813      	ldr	r3, [r2, #0]
    35d4:	f443 0380 	orr.w	r3, r3, #4194304	; 0x400000
    35d8:	6013      	str	r3, [r2, #0]
    35da:	4b06      	ldr	r3, [pc, #24]	; (35f4 <beep_Init+0x24>)
    35dc:	f44f 0280 	mov.w	r2, #4194304	; 0x400000
    35e0:	601a      	str	r2, [r3, #0]
	beep.power = pdOFF; 	// Mantém desligado e emissão de beeps
    35e2:	4b05      	ldr	r3, [pc, #20]	; (35f8 <beep_Init+0x28>)
    35e4:	781a      	ldrb	r2, [r3, #0]
    35e6:	f36f 0200 	bfc	r2, #0, #1
    35ea:	701a      	strb	r2, [r3, #0]
    35ec:	4770      	bx	lr
    35ee:	bf00      	nop
    35f0:	2009c000 	.word	0x2009c000
    35f4:	2009c01c 	.word	0x2009c01c
    35f8:	10000824 	.word	0x10000824

Disassembly of section .text.beep_Play:

000035fc <beep_Play>:
//			beep1SHORTBEEP 			Emissão de um beep curto
//			beep3SHORTBEEP 			Emissão de três beeps curtos
//			beepCONTINUOUS_2xONOFF	Emissão de dois beeps curtos em intervalos
//			beep1LONG2SHORTBEEP		Emissão um beep longo e dois beeps curtos
// -------------------------------------------------------------------------------------------------------------------
void beep_Play(uint type) {
    35fc:	b510      	push	{r4, lr}
    35fe:	4c07      	ldr	r4, [pc, #28]	; (361c <beep_Play+0x20>)
	if (type) {
    3600:	b130      	cbz	r0, 3610 <beep_Play+0x14>
		beep.type = type;
    3602:	6060      	str	r0, [r4, #4]
		beep_SetType();
    3604:	f7ff ffa0 	bl	3548 <beep_SetType>
		beep.power = pdON;
    3608:	7823      	ldrb	r3, [r4, #0]
    360a:	f043 0301 	orr.w	r3, r3, #1
    360e:	e002      	b.n	3616 <beep_Play+0x1a>
	} else beep.power = pdOFF;
    3610:	7823      	ldrb	r3, [r4, #0]
    3612:	f360 0300 	bfi	r3, r0, #0, #1
    3616:	7023      	strb	r3, [r4, #0]
    3618:	bd10      	pop	{r4, pc}
    361a:	bf00      	nop
    361c:	10000824 	.word	0x10000824

Disassembly of section .text.beep_Tick:

00003620 <beep_Tick>:
// -------------------------------------------------------------------------------------------------------------------
//static uint interval = 0;

void beep_Tick(void) {
	// Se não é para emitir som, vamos desligar o buzzer e sair fora
	if (beep.power == pdOFF) {
    3620:	481f      	ldr	r0, [pc, #124]	; (36a0 <beep_Tick+0x80>)
// -------------------------------------------------------------------------------------------------------------------
// Descrição:	Evento a ser chamado a cada 1ms para control de emissão sonora
// -------------------------------------------------------------------------------------------------------------------
//static uint interval = 0;

void beep_Tick(void) {
    3622:	b510      	push	{r4, lr}
	// Se não é para emitir som, vamos desligar o buzzer e sair fora
	if (beep.power == pdOFF) {
    3624:	7802      	ldrb	r2, [r0, #0]
    3626:	07d3      	lsls	r3, r2, #31
    3628:	d403      	bmi.n	3632 <beep_Tick+0x12>
		beep_BuzzerOFF();
    362a:	f44f 0280 	mov.w	r2, #4194304	; 0x400000
    362e:	4b1d      	ldr	r3, [pc, #116]	; (36a4 <beep_Tick+0x84>)
    3630:	e005      	b.n	363e <beep_Tick+0x1e>
		return;
	}

	// se é o beep acionado direto liga o buzzer e cai fora
	if (beep.type == beepCONTINUOUS) {
    3632:	6843      	ldr	r3, [r0, #4]
    3634:	2b01      	cmp	r3, #1
    3636:	d104      	bne.n	3642 <beep_Tick+0x22>
		beep_BuzzerON();
    3638:	4b1b      	ldr	r3, [pc, #108]	; (36a8 <beep_Tick+0x88>)
    363a:	f44f 0280 	mov.w	r2, #4194304	; 0x400000
    363e:	601a      	str	r2, [r3, #0]
		return;
    3640:	bd10      	pop	{r4, pc}
	}

	// respeitar o tempo entre emissão de beeps quando for de forma continua
	if (beep.interval) beep.interval--;
    3642:	6ac3      	ldr	r3, [r0, #44]	; 0x2c
    3644:	b10b      	cbz	r3, 364a <beep_Tick+0x2a>
    3646:	3b01      	subs	r3, #1
    3648:	e022      	b.n	3690 <beep_Tick+0x70>
	else {
		if (beep.pulse[beep.index].tOn) { // Checa se ainda é tempo de ficar ativo o buzzer
    364a:	68c1      	ldr	r1, [r0, #12]
    364c:	1c8b      	adds	r3, r1, #2
    364e:	f850 4033 	ldr.w	r4, [r0, r3, lsl #3]
    3652:	b13c      	cbz	r4, 3664 <beep_Tick+0x44>
			beep_BuzzerON(); // Liga o buzzer
    3654:	4a14      	ldr	r2, [pc, #80]	; (36a8 <beep_Tick+0x88>)
    3656:	f44f 0180 	mov.w	r1, #4194304	; 0x400000
			beep.pulse[beep.index].tOn--; // decrementa o tempo de permanecer ligado
    365a:	3c01      	subs	r4, #1

	// respeitar o tempo entre emissão de beeps quando for de forma continua
	if (beep.interval) beep.interval--;
	else {
		if (beep.pulse[beep.index].tOn) { // Checa se ainda é tempo de ficar ativo o buzzer
			beep_BuzzerON(); // Liga o buzzer
    365c:	6011      	str	r1, [r2, #0]
			beep.pulse[beep.index].tOn--; // decrementa o tempo de permanecer ligado
    365e:	f840 4033 	str.w	r4, [r0, r3, lsl #3]
    3662:	bd10      	pop	{r4, pc}
		} else if (beep.pulse[beep.index].tOff) { // Checa se é ainda tempo de ficar desativo o buzzer
    3664:	eb00 03c3 	add.w	r3, r0, r3, lsl #3
    3668:	685c      	ldr	r4, [r3, #4]
    366a:	b134      	cbz	r4, 367a <beep_Tick+0x5a>
			beep_BuzzerOFF(); // desliga o buzzer
    366c:	4a0d      	ldr	r2, [pc, #52]	; (36a4 <beep_Tick+0x84>)
    366e:	f44f 0180 	mov.w	r1, #4194304	; 0x400000
			beep.pulse[beep.index].tOff--; // decrementa o tempo de permanecer desligado
    3672:	3c01      	subs	r4, #1
	else {
		if (beep.pulse[beep.index].tOn) { // Checa se ainda é tempo de ficar ativo o buzzer
			beep_BuzzerON(); // Liga o buzzer
			beep.pulse[beep.index].tOn--; // decrementa o tempo de permanecer ligado
		} else if (beep.pulse[beep.index].tOff) { // Checa se é ainda tempo de ficar desativo o buzzer
			beep_BuzzerOFF(); // desliga o buzzer
    3674:	6011      	str	r1, [r2, #0]
			beep.pulse[beep.index].tOff--; // decrementa o tempo de permanecer desligado
    3676:	605c      	str	r4, [r3, #4]
    3678:	bd10      	pop	{r4, pc}
		// Vamos veriricar se fez todos os beeps e se é para tocar de forma continua o não,
		//	se sim vamos recomeçar, senão para tudo
		} else {
			if (beep.index < beep.nBeeps) // Checa se fez todos os beeps
    367a:	6883      	ldr	r3, [r0, #8]
    367c:	4299      	cmp	r1, r3
    367e:	d202      	bcs.n	3686 <beep_Tick+0x66>
				beep.index++; // vai para o próximo beep
    3680:	3101      	adds	r1, #1
    3682:	60c1      	str	r1, [r0, #12]
    3684:	bd10      	pop	{r4, pc}
			else {
				// se fez todos os beeps vamos checar se tem intervalo entre eles, se tiver vamos reiniciar
				// senão pata tudo
				if (beep.intervalLoad) {
    3686:	6a81      	ldr	r1, [r0, #40]	; 0x28
    3688:	b121      	cbz	r1, 3694 <beep_Tick+0x74>
					beep_SetType(); // reinicia as variáveis
    368a:	f7ff ff5d 	bl	3548 <beep_SetType>
					beep.interval = beep.intervalLoad; // Captura o intervalo
    368e:	6a83      	ldr	r3, [r0, #40]	; 0x28
    3690:	62c3      	str	r3, [r0, #44]	; 0x2c
    3692:	bd10      	pop	{r4, pc}
				} else beep.power = pdOFF; // desliga tudo
    3694:	4613      	mov	r3, r2
    3696:	f361 0300 	bfi	r3, r1, #0, #1
    369a:	7003      	strb	r3, [r0, #0]
    369c:	bd10      	pop	{r4, pc}
    369e:	bf00      	nop
    36a0:	10000824 	.word	0x10000824
    36a4:	2009c01c 	.word	0x2009c01c
    36a8:	2009c018 	.word	0x2009c018

Disassembly of section .text.cli_GetLine:

000036ac <cli_GetLine>:
//				bufferLength: tamanho do buffer
//				*prompt: Prompt para ser exibido
// Retorna	:  A quantidade de dados processado no buffer
// -----------------------------------------------------------------------------------------------------------------
//  bufferLength includes the space reserved for the \0
int cli_GetLine (u8 *buffer, int bufferLength, const char *prompt) {
    36ac:	b5f8      	push	{r3, r4, r5, r6, r7, lr}
  	if (initGet) { // Checa se é incio da entrada de comandos
    36ae:	4f35      	ldr	r7, [pc, #212]	; (3784 <cli_GetLine+0xd8>)
//				bufferLength: tamanho do buffer
//				*prompt: Prompt para ser exibido
// Retorna	:  A quantidade de dados processado no buffer
// -----------------------------------------------------------------------------------------------------------------
//  bufferLength includes the space reserved for the \0
int cli_GetLine (u8 *buffer, int bufferLength, const char *prompt) {
    36b0:	4604      	mov	r4, r0
  	if (initGet) { // Checa se é incio da entrada de comandos
    36b2:	783b      	ldrb	r3, [r7, #0]
//				bufferLength: tamanho do buffer
//				*prompt: Prompt para ser exibido
// Retorna	:  A quantidade de dados processado no buffer
// -----------------------------------------------------------------------------------------------------------------
//  bufferLength includes the space reserved for the \0
int cli_GetLine (u8 *buffer, int bufferLength, const char *prompt) {
    36b4:	460e      	mov	r6, r1
  	if (initGet) { // Checa se é incio da entrada de comandos
    36b6:	b143      	cbz	r3, 36ca <cli_GetLine+0x1e>
  		lprintf("%s", prompt);
    36b8:	4933      	ldr	r1, [pc, #204]	; (3788 <cli_GetLine+0xdc>)
    36ba:	2001      	movs	r0, #1
    36bc:	f7ff fd82 	bl	31c4 <rprintf>
  	  	p = buffer;
    36c0:	4b32      	ldr	r3, [pc, #200]	; (378c <cli_GetLine+0xe0>)
    36c2:	601c      	str	r4, [r3, #0]
  	  	*p = '\0';
    36c4:	2300      	movs	r3, #0
    36c6:	7023      	strb	r3, [r4, #0]
  	  	initGet = 0;
    36c8:	703b      	strb	r3, [r7, #0]
  	}

  	//while (1) { // FOI RETIRADO PARA QUE NÃO FIQUE NO LOOP ATÉ CHEGADA DO ENTER, PARA QUE OUTRAS FUNÇÕES SEJAM PROCESSADAS COMO UIP
    if (lgetchar(&c) == pdPASS) {
    36ca:	4d31      	ldr	r5, [pc, #196]	; (3790 <cli_GetLine+0xe4>)
    36cc:	4628      	mov	r0, r5
    36ce:	f7ff fd73 	bl	31b8 <lgetchar>
    36d2:	2801      	cmp	r0, #1
    36d4:	4603      	mov	r3, r0
    36d6:	d150      	bne.n	377a <cli_GetLine+0xce>
	  	switch (c) {
    36d8:	782a      	ldrb	r2, [r5, #0]
    36da:	2a0d      	cmp	r2, #13
    36dc:	d010      	beq.n	3700 <cli_GetLine+0x54>
    36de:	d804      	bhi.n	36ea <cli_GetLine+0x3e>
    36e0:	2a08      	cmp	r2, #8
    36e2:	d018      	beq.n	3716 <cli_GetLine+0x6a>
    36e4:	2a0a      	cmp	r2, #10
    36e6:	d00b      	beq.n	3700 <cli_GetLine+0x54>
    36e8:	e031      	b.n	374e <cli_GetLine+0xa2>
    36ea:	2a15      	cmp	r2, #21
    36ec:	d101      	bne.n	36f2 <cli_GetLine+0x46>
        	}
        	break;
        	break;

	    case 0x15 : // CTRL-U
    		while (p != buffer) {
    36ee:	4d27      	ldr	r5, [pc, #156]	; (378c <cli_GetLine+0xe0>)
    36f0:	e01f      	b.n	3732 <cli_GetLine+0x86>
  	  	initGet = 0;
  	}

  	//while (1) { // FOI RETIRADO PARA QUE NÃO FIQUE NO LOOP ATÉ CHEGADA DO ENTER, PARA QUE OUTRAS FUNÇÕES SEJAM PROCESSADAS COMO UIP
    if (lgetchar(&c) == pdPASS) {
	  	switch (c) {
    36f2:	d32c      	bcc.n	374e <cli_GetLine+0xa2>
    36f4:	2afe      	cmp	r2, #254	; 0xfe
    36f6:	d32a      	bcc.n	374e <cli_GetLine+0xa2>
      		*p = '\0';
      		break;

	    case 0xfe :
    	case 0xff :
        	*buffer++ = c;
    36f8:	7022      	strb	r2, [r4, #0]
        	*buffer = '\0';
    36fa:	2200      	movs	r2, #0
    36fc:	7062      	strb	r2, [r4, #1]
        	return 1;
    36fe:	e03f      	b.n	3780 <cli_GetLine+0xd4>
  	//while (1) { // FOI RETIRADO PARA QUE NÃO FIQUE NO LOOP ATÉ CHEGADA DO ENTER, PARA QUE OUTRAS FUNÇÕES SEJAM PROCESSADAS COMO UIP
    if (lgetchar(&c) == pdPASS) {
	  	switch (c) {
		case '\r' : // por causa da tecla enter do prompt no PROTEUS que envia \r
    	case '\n' : // estamos usando o finalizar de comandos "\n" ou "\r\n", logo  vamos podemos ignorar o "\r" e usar "\n"
    		lprintf(CMD_TERMINATOR);
    3700:	4924      	ldr	r1, [pc, #144]	; (3794 <cli_GetLine+0xe8>)
    3702:	2001      	movs	r0, #1
    3704:	f7ff fd5e 	bl	31c4 <rprintf>
    		initGet = 1;
    3708:	2301      	movs	r3, #1
    370a:	703b      	strb	r3, [r7, #0]
    		return strlen ((char *) buffer);
    370c:	4620      	mov	r0, r4
      	}
    }
  	//}

  	return 0;
}
    370e:	e8bd 40f8 	ldmia.w	sp!, {r3, r4, r5, r6, r7, lr}
	  	switch (c) {
		case '\r' : // por causa da tecla enter do prompt no PROTEUS que envia \r
    	case '\n' : // estamos usando o finalizar de comandos "\n" ou "\r\n", logo  vamos podemos ignorar o "\r" e usar "\n"
    		lprintf(CMD_TERMINATOR);
    		initGet = 1;
    		return strlen ((char *) buffer);
    3712:	f001 b9df 	b.w	4ad4 <strlen>

    	case '\b' :
    		if (p > buffer) {
    3716:	4a1d      	ldr	r2, [pc, #116]	; (378c <cli_GetLine+0xe0>)
    3718:	6813      	ldr	r3, [r2, #0]
    371a:	429c      	cmp	r4, r3
    371c:	f04f 0400 	mov.w	r4, #0
    3720:	d22d      	bcs.n	377e <cli_GetLine+0xd2>
    			*--p = '\0';
    3722:	1e59      	subs	r1, r3, #1
    3724:	6011      	str	r1, [r2, #0]
    3726:	f803 4c01 	strb.w	r4, [r3, #-1]
        		lprintf("\b \b");
    372a:	491b      	ldr	r1, [pc, #108]	; (3798 <cli_GetLine+0xec>)
    372c:	f7ff fd4a 	bl	31c4 <rprintf>
    3730:	e025      	b.n	377e <cli_GetLine+0xd2>
        	}
        	break;
        	break;

	    case 0x15 : // CTRL-U
    		while (p != buffer) {
    3732:	682b      	ldr	r3, [r5, #0]
    3734:	429c      	cmp	r4, r3
    3736:	d007      	beq.n	3748 <cli_GetLine+0x9c>
    			lprintf("\b \b");
    3738:	4917      	ldr	r1, [pc, #92]	; (3798 <cli_GetLine+0xec>)
    373a:	2001      	movs	r0, #1
    373c:	f7ff fd42 	bl	31c4 <rprintf>
            	--p;
    3740:	682b      	ldr	r3, [r5, #0]
    3742:	3b01      	subs	r3, #1
    3744:	602b      	str	r3, [r5, #0]
    3746:	e7f4      	b.n	3732 <cli_GetLine+0x86>
	        }
      		*p = '\0';
    3748:	2300      	movs	r3, #0
    374a:	7023      	strb	r3, [r4, #0]
      		break;
    374c:	e018      	b.n	3780 <cli_GetLine+0xd4>
        	*buffer++ = c;
        	*buffer = '\0';
        	return 1;
	        		
	    default :
	    	if (p < buffer + bufferLength - 1 && c >= ' ' && c < 0x7f) {
    374e:	490f      	ldr	r1, [pc, #60]	; (378c <cli_GetLine+0xe0>)
    3750:	3e01      	subs	r6, #1
    3752:	680b      	ldr	r3, [r1, #0]
    3754:	4434      	add	r4, r6
    3756:	42a3      	cmp	r3, r4
    3758:	d20f      	bcs.n	377a <cli_GetLine+0xce>
    375a:	f1a2 0020 	sub.w	r0, r2, #32
    375e:	285e      	cmp	r0, #94	; 0x5e
    3760:	f04f 0400 	mov.w	r4, #0
    3764:	d80b      	bhi.n	377e <cli_GetLine+0xd2>
        		*p++ = c;
    3766:	1c58      	adds	r0, r3, #1
    3768:	701a      	strb	r2, [r3, #0]
    376a:	6008      	str	r0, [r1, #0]
            	*p = '\0';
    376c:	705c      	strb	r4, [r3, #1]
            	lprintf("%c", c);
    376e:	782a      	ldrb	r2, [r5, #0]
    3770:	490a      	ldr	r1, [pc, #40]	; (379c <cli_GetLine+0xf0>)
    3772:	2001      	movs	r0, #1
    3774:	f7ff fd26 	bl	31c4 <rprintf>
    3778:	e001      	b.n	377e <cli_GetLine+0xd2>
	    	break;
      	}
    }
  	//}

  	return 0;
    377a:	2300      	movs	r3, #0
    377c:	e000      	b.n	3780 <cli_GetLine+0xd4>
    377e:	4623      	mov	r3, r4
}
    3780:	4618      	mov	r0, r3
    3782:	bdf8      	pop	{r3, r4, r5, r6, r7, pc}
    3784:	1000003c 	.word	0x1000003c
    3788:	0000a624 	.word	0x0000a624
    378c:	10000858 	.word	0x10000858
    3790:	1000085c 	.word	0x1000085c
    3794:	000059ed 	.word	0x000059ed
    3798:	0000a627 	.word	0x0000a627
    379c:	0000a60d 	.word	0x0000a60d

Disassembly of section .text.cli_Help:

000037a0 <cli_Help>:
// -----------------------------------------------------------------------------------------------------------------
// Descrição:	Exibe a lista de comandos de help dos comandos
// Parametros:
// Retorna:
// -----------------------------------------------------------------------------------------------------------------
int cli_Help (int argc __attribute__ ((unused)), portCHAR **argv __attribute__ ((unused))) {
    37a0:	e92d 41f0 	stmdb	sp!, {r4, r5, r6, r7, r8, lr}
  	int longestCmd;
  	portCHAR spaces [32];

  	memset (spaces, ' ', sizeof (spaces));

  	for (longestCmd = 0, i = 0; cmd_list_active[i].command; i++)
    37a4:	2500      	movs	r5, #0
    37a6:	462c      	mov	r4, r5
// -----------------------------------------------------------------------------------------------------------------
// Descrição:	Exibe a lista de comandos de help dos comandos
// Parametros:
// Retorna:
// -----------------------------------------------------------------------------------------------------------------
int cli_Help (int argc __attribute__ ((unused)), portCHAR **argv __attribute__ ((unused))) {
    37a8:	b08a      	sub	sp, #40	; 0x28
  	unsigned int i;
  	int t;
  	int longestCmd;
  	portCHAR spaces [32];

  	memset (spaces, ' ', sizeof (spaces));
    37aa:	2220      	movs	r2, #32

  	for (longestCmd = 0, i = 0; cmd_list_active[i].command; i++)
    37ac:	4e1e      	ldr	r6, [pc, #120]	; (3828 <cli_Help+0x88>)
  	unsigned int i;
  	int t;
  	int longestCmd;
  	portCHAR spaces [32];

  	memset (spaces, ' ', sizeof (spaces));
    37ae:	4611      	mov	r1, r2
    37b0:	a802      	add	r0, sp, #8
    37b2:	f001 f941 	bl	4a38 <memset>

  	for (longestCmd = 0, i = 0; cmd_list_active[i].command; i++)
    37b6:	6837      	ldr	r7, [r6, #0]
    37b8:	3514      	adds	r5, #20
    37ba:	197b      	adds	r3, r7, r5
    37bc:	f853 0c14 	ldr.w	r0, [r3, #-20]
    37c0:	b128      	cbz	r0, 37ce <cli_Help+0x2e>
    	if ((t = strlen (cmd_list_active[i].command)) > longestCmd)
    37c2:	f001 f987 	bl	4ad4 <strlen>
    37c6:	4284      	cmp	r4, r0
    37c8:	bfb8      	it	lt
    37ca:	4604      	movlt	r4, r0
    37cc:	e7f4      	b.n	37b8 <cli_Help+0x18>
      		longestCmd = t;

  	spaces [longestCmd] = '\0';
    37ce:	ab0a      	add	r3, sp, #40	; 0x28
    37d0:	441c      	add	r4, r3
    37d2:	f804 0c20 	strb.w	r0, [r4, #-32]

  	for (i = 0; cmd_list_active[i].command; i++) {
    37d6:	4604      	mov	r4, r0
    37d8:	6833      	ldr	r3, [r6, #0]
    37da:	591d      	ldr	r5, [r3, r4]
    37dc:	191a      	adds	r2, r3, r4
    37de:	b1dd      	cbz	r5, 3818 <cli_Help+0x78>
    	const tCLI *cl = &cmd_list_active[i];

    	if (cl->cmd_type == CMD_TYPE_FUNCTION)
    37e0:	f892 8006 	ldrb.w	r8, [r2, #6]
    		lprintf("%s%s -- %s"CMD_TERMINATOR, cl->command, &spaces [strlen (cl->command)], cl->description);
    37e4:	4628      	mov	r0, r5
  	spaces [longestCmd] = '\0';

  	for (i = 0; cmd_list_active[i].command; i++) {
    	const tCLI *cl = &cmd_list_active[i];

    	if (cl->cmd_type == CMD_TYPE_FUNCTION)
    37e6:	f1b8 0f01 	cmp.w	r8, #1
    37ea:	68d7      	ldr	r7, [r2, #12]
    37ec:	d108      	bne.n	3800 <cli_Help+0x60>
    		lprintf("%s%s -- %s"CMD_TERMINATOR, cl->command, &spaces [strlen (cl->command)], cl->description);
    37ee:	f001 f971 	bl	4ad4 <strlen>
    37f2:	ab02      	add	r3, sp, #8
    37f4:	4403      	add	r3, r0
    37f6:	9700      	str	r7, [sp, #0]
    37f8:	462a      	mov	r2, r5
    37fa:	490c      	ldr	r1, [pc, #48]	; (382c <cli_Help+0x8c>)
    37fc:	4640      	mov	r0, r8
    37fe:	e007      	b.n	3810 <cli_Help+0x70>
    	else
    		lprintf("%s%s -- " CLI_MSG_SUB_LIST " - %s"CMD_TERMINATOR, cl->command, &spaces [strlen (cl->command)], cl->description);
    3800:	f001 f968 	bl	4ad4 <strlen>
    3804:	462a      	mov	r2, r5
    3806:	ab02      	add	r3, sp, #8
    3808:	4909      	ldr	r1, [pc, #36]	; (3830 <cli_Help+0x90>)
    380a:	4403      	add	r3, r0
    380c:	9700      	str	r7, [sp, #0]
    380e:	2001      	movs	r0, #1
    3810:	f7ff fcd8 	bl	31c4 <rprintf>
    3814:	3414      	adds	r4, #20
    3816:	e7df      	b.n	37d8 <cli_Help+0x38>
  	}

  	lprintf(CLI_MSG_HELP);
    3818:	4906      	ldr	r1, [pc, #24]	; (3834 <cli_Help+0x94>)
    381a:	2001      	movs	r0, #1
    381c:	f7ff fcd2 	bl	31c4 <rprintf>

  	return pdPASS;
}
    3820:	2001      	movs	r0, #1
    3822:	b00a      	add	sp, #40	; 0x28
    3824:	e8bd 81f0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, pc}
    3828:	10000854 	.word	0x10000854
    382c:	0000a62b 	.word	0x0000a62b
    3830:	0000a637 	.word	0x0000a637
    3834:	0000a64d 	.word	0x0000a64d

Disassembly of section .text.cli_ArgsParse:

00003838 <cli_ArgsParse>:
  	P_GET_INIT_ARGS,
  	P_SET_END_ARGS,
  	P_SET_END_QUOTE
} p_state_t;

int cli_ArgsParse (char *cmd, char **argv, int sizeofArgv, int *argc) {
    3838:	e92d 47f0 	stmdb	sp!, {r4, r5, r6, r7, r8, r9, sl, lr}
    383c:	4604      	mov	r4, r0
  	int max_args = (sizeofArgv / sizeof (argv [0])) - 1;	// Determina a quantidade máximo de argumetos que podem ser gravados no argv
    383e:	0897      	lsrs	r7, r2, #2
  	P_GET_INIT_ARGS,
  	P_SET_END_ARGS,
  	P_SET_END_QUOTE
} p_state_t;

int cli_ArgsParse (char *cmd, char **argv, int sizeofArgv, int *argc) {
    3840:	460e      	mov	r6, r1
    3842:	4691      	mov	r9, r2
    3844:	4698      	mov	r8, r3
//				Ou seja, retira os espaços em branco do lado dirieto e esquerdo da string
// Parametros: ponteiro da string
// Retorna:		Ponteiro da strinf na posição onde começa o comando
// -----------------------------------------------------------------------------------------------------------------
static char *strtrim (char *s) {
  	char *t = s + strlen (s) - 1; 			// Aponta o endereço para o último caractere da string
    3846:	f001 f945 	bl	4ad4 <strlen>
    384a:	3801      	subs	r0, #1
  	P_SET_END_ARGS,
  	P_SET_END_QUOTE
} p_state_t;

int cli_ArgsParse (char *cmd, char **argv, int sizeofArgv, int *argc) {
  	int max_args = (sizeofArgv / sizeof (argv [0])) - 1;	// Determina a quantidade máximo de argumetos que podem ser gravados no argv
    384c:	3f01      	subs	r7, #1
//				Ou seja, retira os espaços em branco do lado dirieto e esquerdo da string
// Parametros: ponteiro da string
// Retorna:		Ponteiro da strinf na posição onde começa o comando
// -----------------------------------------------------------------------------------------------------------------
static char *strtrim (char *s) {
  	char *t = s + strlen (s) - 1; 			// Aponta o endereço para o último caractere da string
    384e:	1825      	adds	r5, r4, r0

  	// COLOCO O FINALIZAR LOGO APÓS O COMANDO. OU SEJA, RETIRA OS ESPAÇOS EM BRANCO DO LADO DIREITO DA STRING
  	while (t >= s && *t && isspace ((int)*t)) 	// Faça enquanto o endereço t seja maior ou igual ao endereço da string e se o caractere for um whitespace
  		*t-- = '\0'; 						// Posição atual da string recebe nulo e aponto para o endereço anterior na string
    3850:	f04f 0a00 	mov.w	sl, #0
// -----------------------------------------------------------------------------------------------------------------
static char *strtrim (char *s) {
  	char *t = s + strlen (s) - 1; 			// Aponta o endereço para o último caractere da string

  	// COLOCO O FINALIZAR LOGO APÓS O COMANDO. OU SEJA, RETIRA OS ESPAÇOS EM BRANCO DO LADO DIREITO DA STRING
  	while (t >= s && *t && isspace ((int)*t)) 	// Faça enquanto o endereço t seja maior ou igual ao endereço da string e se o caractere for um whitespace
    3854:	42ac      	cmp	r4, r5
    3856:	d813      	bhi.n	3880 <cli_ArgsParse+0x48>
    3858:	782b      	ldrb	r3, [r5, #0]
    385a:	b18b      	cbz	r3, 3880 <cli_ArgsParse+0x48>
    385c:	f001 f8cc 	bl	49f8 <__locale_ctype_ptr>
    3860:	782b      	ldrb	r3, [r5, #0]
    3862:	4418      	add	r0, r3
    3864:	7843      	ldrb	r3, [r0, #1]
    3866:	071b      	lsls	r3, r3, #28
    3868:	d50a      	bpl.n	3880 <cli_ArgsParse+0x48>
  		*t-- = '\0'; 						// Posição atual da string recebe nulo e aponto para o endereço anterior na string
    386a:	f805 a901 	strb.w	sl, [r5], #-1
    386e:	e7f1      	b.n	3854 <cli_ArgsParse+0x1c>

  	// ENCONTRA O INICIO DO COMANDO. OU SEJA, RETIRA OS ESPAÇOS EM BRANCO DO LADO ESQUERDO DA STRING
  	while (*s && isspace ((int)*s)) 		// Faça enquanto o endereço s seja menor que o endereço final da string e se o caractere for um whitespace
    3870:	f001 f8c2 	bl	49f8 <__locale_ctype_ptr>
    3874:	782b      	ldrb	r3, [r5, #0]
    3876:	3401      	adds	r4, #1
    3878:	4418      	add	r0, r3
    387a:	7843      	ldrb	r3, [r0, #1]
    387c:	0718      	lsls	r0, r3, #28
    387e:	d503      	bpl.n	3888 <cli_ArgsParse+0x50>
    3880:	7823      	ldrb	r3, [r4, #0]
    3882:	4625      	mov	r5, r4
    3884:	2b00      	cmp	r3, #0
    3886:	d1f3      	bne.n	3870 <cli_ArgsParse+0x38>
  	int max_args = (sizeofArgv / sizeof (argv [0])) - 1;	// Determina a quantidade máximo de argumetos que podem ser gravados no argv
  	char *s = strtrim (cmd); 								// Retira espaços em branco ou caracteres de controle do lado direto ou esquerdo da string e captura o endereço do comando
  	
  	p_state_t pstate = P_WAIT_INIT_ARGS;					// Sinalizo para esperar pelo separado de argumentos que é o espaço em branco

  	*argc = 0;												// Sinaliza que ainda não capturou nenhum argumento
    3888:	2400      	movs	r4, #0
  	memset (argv, 0, sizeofArgv); 							// Preenche os endereços do argv com valores 0, ou seja, limpa todos os endereços
    388a:	464a      	mov	r2, r9
  	int max_args = (sizeofArgv / sizeof (argv [0])) - 1;	// Determina a quantidade máximo de argumetos que podem ser gravados no argv
  	char *s = strtrim (cmd); 								// Retira espaços em branco ou caracteres de controle do lado direto ou esquerdo da string e captura o endereço do comando
  	
  	p_state_t pstate = P_WAIT_INIT_ARGS;					// Sinalizo para esperar pelo separado de argumentos que é o espaço em branco

  	*argc = 0;												// Sinaliza que ainda não capturou nenhum argumento
    388c:	f8c8 4000 	str.w	r4, [r8]
  	memset (argv, 0, sizeofArgv); 							// Preenche os endereços do argv com valores 0, ou seja, limpa todos os endereços
    3890:	4621      	mov	r1, r4
    3892:	4630      	mov	r0, r6
    3894:	f001 f8d0 	bl	4a38 <memset>

      		// ENCONTRA FIM DO ARGUMENTO E SINALIZA NA POSIÇÃO, ENDEREÇO, DO COMANDO COM O CARACTERE NULO
      		case P_SET_END_ARGS : {
          		if (isspace ((int)*s)) {							// Checa se o caractere atual é um whitespace
            		pstate = P_WAIT_INIT_ARGS;				// Sinaliza para ir a estado para captura do prróximo argumento
            		*s = '\0';								// Sinaliza na posição atual que é o fim do argumento atual
    3898:	46a1      	mov	r9, r4
  	p_state_t pstate = P_WAIT_INIT_ARGS;					// Sinalizo para esperar pelo separado de argumentos que é o espaço em branco

  	*argc = 0;												// Sinaliza que ainda não capturou nenhum argumento
  	memset (argv, 0, sizeofArgv); 							// Preenche os endereços do argv com valores 0, ou seja, limpa todos os endereços
  	
  	while (*s) {											// Fazer para toda os caracteres do comando
    389a:	e010      	b.n	38be <cli_ArgsParse+0x86>

      		// CAPTURO A POSIÇÃO, ENDEREÇO, INICIAL DO ARGUMENTO NO VETOR DE COMANDOS
      		case P_GET_INIT_ARGS : {
          		*argv++ = s; 								// Captura o endereço S, posição X do buffer, e aponta para o próxima posição do ponteiro de argumentos

          		if (++*argc == max_args)					// Incremento a quantidade de argumetos encontrado e checa se está no limite máximo de argumentos
    389c:	f8d8 3000 	ldr.w	r3, [r8]
        	}
        	break;

      		// CAPTURO A POSIÇÃO, ENDEREÇO, INICIAL DO ARGUMENTO NO VETOR DE COMANDOS
      		case P_GET_INIT_ARGS : {
          		*argv++ = s; 								// Captura o endereço S, posição X do buffer, e aponta para o próxima posição do ponteiro de argumentos
    38a0:	6035      	str	r5, [r6, #0]

          		if (++*argc == max_args)					// Incremento a quantidade de argumetos encontrado e checa se está no limite máximo de argumentos
    38a2:	3301      	adds	r3, #1
    38a4:	429f      	cmp	r7, r3
        	}
        	break;

      		// CAPTURO A POSIÇÃO, ENDEREÇO, INICIAL DO ARGUMENTO NO VETOR DE COMANDOS
      		case P_GET_INIT_ARGS : {
          		*argv++ = s; 								// Captura o endereço S, posição X do buffer, e aponta para o próxima posição do ponteiro de argumentos
    38a6:	f106 0204 	add.w	r2, r6, #4

          		if (++*argc == max_args)					// Incremento a quantidade de argumetos encontrado e checa se está no limite máximo de argumentos
    38aa:	f8c8 3000 	str.w	r3, [r8]
    38ae:	d036      	beq.n	391e <cli_ArgsParse+0xe6>
        	}
        	break;

      		// CAPTURO A POSIÇÃO, ENDEREÇO, INICIAL DO ARGUMENTO NO VETOR DE COMANDOS
      		case P_GET_INIT_ARGS : {
          		*argv++ = s; 								// Captura o endereço S, posição X do buffer, e aponta para o próxima posição do ponteiro de argumentos
    38b0:	4616      	mov	r6, r2

          		if (++*argc == max_args)					// Incremento a quantidade de argumetos encontrado e checa se está no limite máximo de argumentos
        	    	return errCLI_EXED_ARGS;					// Retorna erro
	          	if (*s == '"')								// Checa se encontramos o caractere aspa. Sinaliza inicio do parametro de string contend espaços em branco internos
    38b2:	f815 3b01 	ldrb.w	r3, [r5], #1
    	        	pstate = P_SET_END_QUOTE;				// Vai ao estado de encontrar fim das aspas, isto porque nesta condição consideramos o espaço em branco como conteúdo do parametro 
        	  	else
            		pstate = P_SET_END_ARGS;				// Vai ao estado de de encontrar fim do argumento
    38b6:	2b22      	cmp	r3, #34	; 0x22
    38b8:	bf0c      	ite	eq
    38ba:	2403      	moveq	r4, #3
    38bc:	2402      	movne	r4, #2
  	p_state_t pstate = P_WAIT_INIT_ARGS;					// Sinalizo para esperar pelo separado de argumentos que é o espaço em branco

  	*argc = 0;												// Sinaliza que ainda não capturou nenhum argumento
  	memset (argv, 0, sizeofArgv); 							// Preenche os endereços do argv com valores 0, ou seja, limpa todos os endereços
  	
  	while (*s) {											// Fazer para toda os caracteres do comando
    38be:	782b      	ldrb	r3, [r5, #0]
    38c0:	b353      	cbz	r3, 3918 <cli_ArgsParse+0xe0>
    	switch (pstate) {
    38c2:	2c03      	cmp	r4, #3
    38c4:	d8fc      	bhi.n	38c0 <cli_ArgsParse+0x88>
    38c6:	a201      	add	r2, pc, #4	; (adr r2, 38cc <cli_ArgsParse+0x94>)
    38c8:	f852 f024 	ldr.w	pc, [r2, r4, lsl #2]
    38cc:	000038dd 	.word	0x000038dd
    38d0:	0000389d 	.word	0x0000389d
    38d4:	000038ed 	.word	0x000038ed
    38d8:	0000390b 	.word	0x0000390b
      		// PROCURA O INICIO DO ARGUMENTO
      		case P_WAIT_INIT_ARGS :  {						// Checa se estamos esperando pelo separador de argumentos, que é o espaço em branco
          		if (!isspace ((int)*s))  						// Checa se a posição atual não é um white-space, sinalizador de inicio de arqumento
    38dc:	f001 f88c 	bl	49f8 <__locale_ctype_ptr>
    38e0:	782b      	ldrb	r3, [r5, #0]
    38e2:	4418      	add	r0, r3
    38e4:	7843      	ldrb	r3, [r0, #1]
    38e6:	0719      	lsls	r1, r3, #28
    38e8:	d514      	bpl.n	3914 <cli_ArgsParse+0xdc>
    38ea:	e011      	b.n	3910 <cli_ArgsParse+0xd8>
    	    }
        	break;

      		// ENCONTRA FIM DO ARGUMENTO E SINALIZA NA POSIÇÃO, ENDEREÇO, DO COMANDO COM O CARACTERE NULO
      		case P_SET_END_ARGS : {
          		if (isspace ((int)*s)) {							// Checa se o caractere atual é um whitespace
    38ec:	f001 f884 	bl	49f8 <__locale_ctype_ptr>
    38f0:	782b      	ldrb	r3, [r5, #0]
    38f2:	4418      	add	r0, r3
    38f4:	7842      	ldrb	r2, [r0, #1]
    38f6:	0712      	lsls	r2, r2, #28
    38f8:	d503      	bpl.n	3902 <cli_ArgsParse+0xca>
            		pstate = P_WAIT_INIT_ARGS;				// Sinaliza para ir a estado para captura do prróximo argumento
            		*s = '\0';								// Sinaliza na posição atual que é o fim do argumento atual
    38fa:	f885 9000 	strb.w	r9, [r5]
        	break;

      		// ENCONTRA FIM DO ARGUMENTO E SINALIZA NA POSIÇÃO, ENDEREÇO, DO COMANDO COM O CARACTERE NULO
      		case P_SET_END_ARGS : {
          		if (isspace ((int)*s)) {							// Checa se o caractere atual é um whitespace
            		pstate = P_WAIT_INIT_ARGS;				// Sinaliza para ir a estado para captura do prróximo argumento
    38fe:	2400      	movs	r4, #0
    3900:	e006      	b.n	3910 <cli_ArgsParse+0xd8>
            		*s = '\0';								// Sinaliza na posição atual que é o fim do argumento atual
          		}  else if (*s == '"')						// Checa se encontramos o caractere aspa. Sinaliza inicio do parametro de string contend espaços em branco internos
            		pstate = P_SET_END_QUOTE;				// Vai ao estado de encontrar fim do argumentos dentro das aspas, isto porque nesta condição consideramos o espaço em branco como conteúdo do parametor 
    3902:	2b22      	cmp	r3, #34	; 0x22
    3904:	bf08      	it	eq
    3906:	2403      	moveq	r4, #3
    3908:	e002      	b.n	3910 <cli_ArgsParse+0xd8>
       		}
        		break;

      		// ECONTRA O FIM DAS ASPAS PARA SINALIZAR FIM DE ARGUMENTO
      		case P_SET_END_QUOTE : {
          		if (*s == '"')	pstate = P_SET_END_ARGS;	// Checa se encontramos o caractere aspa. Sinaliza final do parametro e vá ao estado para procura do fim de argumento
    390a:	2b22      	cmp	r3, #34	; 0x22
    390c:	bf08      	it	eq
    390e:	2402      	moveq	r4, #2
          		
          		s++;										// Aponto para o próximo endereço do caractere do comando
    3910:	3501      	adds	r5, #1
        	}
        		break;
    3912:	e7d4      	b.n	38be <cli_ArgsParse+0x86>
  	while (*s) {											// Fazer para toda os caracteres do comando
    	switch (pstate) {
      		// PROCURA O INICIO DO ARGUMENTO
      		case P_WAIT_INIT_ARGS :  {						// Checa se estamos esperando pelo separador de argumentos, que é o espaço em branco
          		if (!isspace ((int)*s))  						// Checa se a posição atual não é um white-space, sinalizador de inicio de arqumento
            		pstate = P_GET_INIT_ARGS;				// Sinalizo para ir para o estado de captura do argumento atual
    3914:	2401      	movs	r4, #1
    3916:	e7d2      	b.n	38be <cli_ArgsParse+0x86>
        	}
        		break;
    	}
  	}

  	return pdPASS;												// Retorna que OK
    3918:	2001      	movs	r0, #1
    391a:	e8bd 87f0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, r9, sl, pc}
      		// CAPTURO A POSIÇÃO, ENDEREÇO, INICIAL DO ARGUMENTO NO VETOR DE COMANDOS
      		case P_GET_INIT_ARGS : {
          		*argv++ = s; 								// Captura o endereço S, posição X do buffer, e aponta para o próxima posição do ponteiro de argumentos

          		if (++*argc == max_args)					// Incremento a quantidade de argumetos encontrado e checa se está no limite máximo de argumentos
        	    	return errCLI_EXED_ARGS;					// Retorna erro
    391e:	f06f 003b 	mvn.w	r0, #59	; 0x3b
        		break;
    	}
  	}

  	return pdPASS;												// Retorna que OK
}
    3922:	e8bd 87f0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, r9, sl, pc}
    3926:	bf00      	nop

Disassembly of section .text.cli_ArgsDispatch:

00003928 <cli_ArgsDispatch>:
//              Valor do retorno da função chamada
//              errCLI_CMD_NOT_FOUND: Se não encontrou o comando digitado na lista de comandos
//              errCLI_MANY_ARGS: Caso tenha muitos argumentos para o comando atual
//              errCLI_FEW_ARGS: Caso tenha pouco argumentos para o comando atual
// -----------------------------------------------------------------------------------------------------------------
int cli_ArgsDispatch (const tCLI *cl, int argc, char **argv) {
    3928:	e92d 41f0 	stmdb	sp!, {r4, r5, r6, r7, r8, lr}
    392c:	4604      	mov	r4, r0
    392e:	460d      	mov	r5, r1
    3930:	4616      	mov	r6, r2
  	cmd_list_active = cl;
    3932:	4f20      	ldr	r7, [pc, #128]	; (39b4 <cli_ArgsDispatch+0x8c>)
    3934:	603c      	str	r4, [r7, #0]

  	while (cl->command) { 								// Percorre toda lista de comandos
    3936:	6820      	ldr	r0, [r4, #0]
    3938:	2800      	cmp	r0, #0
    393a:	d036      	beq.n	39aa <cli_ArgsDispatch+0x82>
    	if (!strcmp (cl->command, argv [0])) {			// Checa se o comando atual é o mesmo digitado
    393c:	6831      	ldr	r1, [r6, #0]
    393e:	f7fd fbb5 	bl	10ac <strcmp>
    3942:	bb80      	cbnz	r0, 39a6 <cli_ArgsDispatch+0x7e>
      		int ret = 0;

      		if ((argc == 2) && !strcmp (argv [1], "?")) { // Checa se foi digitaldo ? para o comando 
    3944:	2d02      	cmp	r5, #2
    3946:	d10c      	bne.n	3962 <cli_ArgsDispatch+0x3a>
    3948:	491b      	ldr	r1, [pc, #108]	; (39b8 <cli_ArgsDispatch+0x90>)
    394a:	6870      	ldr	r0, [r6, #4]
    394c:	f7fd fbae 	bl	10ac <strcmp>
    3950:	b938      	cbnz	r0, 3962 <cli_ArgsDispatch+0x3a>
        		lprintf("%s"CMD_TERMINATOR, cl->parameters);		// Exibe ajuda para os parametros
    3952:	6922      	ldr	r2, [r4, #16]
    3954:	4919      	ldr	r1, [pc, #100]	; (39bc <cli_ArgsDispatch+0x94>)
    3956:	2001      	movs	r0, #1
    3958:	f7ff fc34 	bl	31c4 <rprintf>
        		ret = pdPASS;
    395c:	2001      	movs	r0, #1
    395e:	e8bd 81f0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, pc}
      		} else if ((argc - 1) < cl->min_args) {			// Checa se a quantidade de argumentos digitados é menor que o mínimo permitido
    3962:	7922      	ldrb	r2, [r4, #4]
    3964:	4295      	cmp	r5, r2
    3966:	dc07      	bgt.n	3978 <cli_ArgsDispatch+0x50>
        		lprintf(CLI_MSG_FEW_ARGS, cl->min_args);
    3968:	4915      	ldr	r1, [pc, #84]	; (39c0 <cli_ArgsDispatch+0x98>)
    396a:	2001      	movs	r0, #1
    396c:	f7ff fc2a 	bl	31c4 <rprintf>
        		ret = errCLI_FEW_ARGS;
    3970:	f06f 003d 	mvn.w	r0, #61	; 0x3d
    3974:	e8bd 81f0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, pc}
      		} else if (cl->cmd_type == CMD_TYPE_LIST) {		// Checa se é um comando ou uma nome de outra lista
    3978:	79a3      	ldrb	r3, [r4, #6]
    397a:	1e68      	subs	r0, r5, #1
    397c:	b91b      	cbnz	r3, 3986 <cli_ArgsDispatch+0x5e>
        		ret = cli_ArgsDispatch (cl->cmd_list, argc - 1, &argv [1]); // Chama essa a sub lista
    397e:	68a4      	ldr	r4, [r4, #8]
    3980:	4605      	mov	r5, r0
    3982:	3604      	adds	r6, #4
    3984:	e7d6      	b.n	3934 <cli_ArgsDispatch+0xc>
      		} else if ((argc - 1) > cl->max_args) {			// Checa se a quantidade de argumentos digitados é maior que o máximo permitido
    3986:	7962      	ldrb	r2, [r4, #5]
    3988:	4290      	cmp	r0, r2
    398a:	dd07      	ble.n	399c <cli_ArgsDispatch+0x74>
        		lprintf(CLI_MSG_MANY_ARGS, cl->max_args);
    398c:	490d      	ldr	r1, [pc, #52]	; (39c4 <cli_ArgsDispatch+0x9c>)
    398e:	2001      	movs	r0, #1
    3990:	f7ff fc18 	bl	31c4 <rprintf>
        		ret = errCLI_MANY_ARGS;
    3994:	f06f 003c 	mvn.w	r0, #60	; 0x3c
    3998:	e8bd 81f0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, pc}
      		} else {
        		ret = (*cl->handler) (argc - 1, &argv [1]); // Chama a função anexado a esse comando
    399c:	68a3      	ldr	r3, [r4, #8]
    399e:	1d31      	adds	r1, r6, #4

  	//if (!cl->command)
    	//lprintf(CLI_MSG_UNKNOWN_CMD " \"%sCMD_TERMINATOR, argv [0]);

  	return errCLI_CMD_NOT_FOUND;
}
    39a0:	e8bd 41f0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, lr}
        		ret = cli_ArgsDispatch (cl->cmd_list, argc - 1, &argv [1]); // Chama essa a sub lista
      		} else if ((argc - 1) > cl->max_args) {			// Checa se a quantidade de argumentos digitados é maior que o máximo permitido
        		lprintf(CLI_MSG_MANY_ARGS, cl->max_args);
        		ret = errCLI_MANY_ARGS;
      		} else {
        		ret = (*cl->handler) (argc - 1, &argv [1]); // Chama a função anexado a esse comando
    39a4:	4718      	bx	r3
        	}

      		return ret;										// Retorna o valor de retorno da função ou 0 se não chamou função alguma
    	}

    	cl++;											// aponta para o próximo comando na lista 
    39a6:	3414      	adds	r4, #20
    39a8:	e7c5      	b.n	3936 <cli_ArgsDispatch+0xe>
  	}

  	//if (!cl->command)
    	//lprintf(CLI_MSG_UNKNOWN_CMD " \"%sCMD_TERMINATOR, argv [0]);

  	return errCLI_CMD_NOT_FOUND;
    39aa:	f06f 003e 	mvn.w	r0, #62	; 0x3e
}
    39ae:	e8bd 81f0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, pc}
    39b2:	bf00      	nop
    39b4:	10000854 	.word	0x10000854
    39b8:	0000a678 	.word	0x0000a678
    39bc:	0000a649 	.word	0x0000a649
    39c0:	0000a67a 	.word	0x0000a67a
    39c4:	0000a69b 	.word	0x0000a69b

Disassembly of section .text.tft_Reset:

000039c8 <tft_Reset>:
  	delay_ms(120);
  	tft_WriteCommand(ILI9341_DISPON);    //Display on
}

#if (ILI9341_USE_RESET == pdON)
void tft_Reset(void) {
    39c8:	b538      	push	{r3, r4, r5, lr}
    ili9341_ResetOff();
    39ca:	4d08      	ldr	r5, [pc, #32]	; (39ec <tft_Reset+0x24>)
    39cc:	2401      	movs	r4, #1
    39ce:	602c      	str	r4, [r5, #0]
    delay_ms(5);
    39d0:	4807      	ldr	r0, [pc, #28]	; (39f0 <tft_Reset+0x28>)
    39d2:	f7fe f8cf 	bl	1b74 <delay>
	ili9341_ResetOn();
    39d6:	4b07      	ldr	r3, [pc, #28]	; (39f4 <tft_Reset+0x2c>)
    delay_ms(20);
    39d8:	4807      	ldr	r0, [pc, #28]	; (39f8 <tft_Reset+0x30>)

#if (ILI9341_USE_RESET == pdON)
void tft_Reset(void) {
    ili9341_ResetOff();
    delay_ms(5);
	ili9341_ResetOn();
    39da:	601c      	str	r4, [r3, #0]
    delay_ms(20);
    39dc:	f7fe f8ca 	bl	1b74 <delay>
	ili9341_ResetOff();
    39e0:	602c      	str	r4, [r5, #0]
    delay_ms(150);
    39e2:	4806      	ldr	r0, [pc, #24]	; (39fc <tft_Reset+0x34>)
}
    39e4:	e8bd 4038 	ldmia.w	sp!, {r3, r4, r5, lr}
    ili9341_ResetOff();
    delay_ms(5);
	ili9341_ResetOn();
    delay_ms(20);
	ili9341_ResetOff();
    delay_ms(150);
    39e8:	f7fe b8c4 	b.w	1b74 <delay>
    39ec:	2009c058 	.word	0x2009c058
    39f0:	00028870 	.word	0x00028870
    39f4:	2009c05c 	.word	0x2009c05c
    39f8:	000a2990 	.word	0x000a2990
    39fc:	004c4b40 	.word	0x004c4b40

Disassembly of section .text.tft_WriteCommand:

00003a00 <tft_WriteCommand>:
}
#endif

void tft_WriteCommand(u8 c) {
    3a00:	b510      	push	{r4, lr}
  	ili9341_Command();
    3a02:	4b06      	ldr	r3, [pc, #24]	; (3a1c <tft_WriteCommand+0x1c>)
    3a04:	2202      	movs	r2, #2
  	ili9341_Enable();
    3a06:	f44f 2480 	mov.w	r4, #262144	; 0x40000
    delay_ms(150);
}
#endif

void tft_WriteCommand(u8 c) {
  	ili9341_Command();
    3a0a:	601a      	str	r2, [r3, #0]
  	ili9341_Enable();
    3a0c:	f843 4c40 	str.w	r4, [r3, #-64]
  	ili9341_TransferByte(c);
    3a10:	f7fe fa94 	bl	1f3c <ssp1_TransferByte>
  	ili9341_Disable();
    3a14:	4b02      	ldr	r3, [pc, #8]	; (3a20 <tft_WriteCommand+0x20>)
    3a16:	601c      	str	r4, [r3, #0]
    3a18:	bd10      	pop	{r4, pc}
    3a1a:	bf00      	nop
    3a1c:	2009c05c 	.word	0x2009c05c
    3a20:	2009c018 	.word	0x2009c018

Disassembly of section .text.tft_WriteData:

00003a24 <tft_WriteData>:
}

void tft_WriteData(u8 c) {
    3a24:	b510      	push	{r4, lr}
	ili9341_Data();
    3a26:	4b06      	ldr	r3, [pc, #24]	; (3a40 <tft_WriteData+0x1c>)
    3a28:	2202      	movs	r2, #2
  	ili9341_Enable();
    3a2a:	f44f 2480 	mov.w	r4, #262144	; 0x40000
  	ili9341_TransferByte(c);
  	ili9341_Disable();
}

void tft_WriteData(u8 c) {
	ili9341_Data();
    3a2e:	601a      	str	r2, [r3, #0]
  	ili9341_Enable();
    3a30:	f843 4c3c 	str.w	r4, [r3, #-60]
  	ili9341_TransferByte(c);
    3a34:	f7fe fa82 	bl	1f3c <ssp1_TransferByte>
  	ili9341_Disable();
    3a38:	4b02      	ldr	r3, [pc, #8]	; (3a44 <tft_WriteData+0x20>)
    3a3a:	601c      	str	r4, [r3, #0]
    3a3c:	bd10      	pop	{r4, pc}
    3a3e:	bf00      	nop
    3a40:	2009c058 	.word	0x2009c058
    3a44:	2009c018 	.word	0x2009c018

Disassembly of section .text.tft_Init:

00003a48 <tft_Init>:
//				O acesso é feito via barramento SPI no modo padrão com velocidade máxima de 8MHz
// Parametros	Nenhum
// Retorna: 	Nada
//------------------------------------------------------------------------------------------------------------------
void tft_Init(void) {
	ili9341_SetupPorts();	// Configurar os pinos de controle
    3a48:	4a8b      	ldr	r2, [pc, #556]	; (3c78 <tft_Init+0x230>)
// Descrição:	Inicializa pinos do controlador e o driver controlador
//				O acesso é feito via barramento SPI no modo padrão com velocidade máxima de 8MHz
// Parametros	Nenhum
// Retorna: 	Nada
//------------------------------------------------------------------------------------------------------------------
void tft_Init(void) {
    3a4a:	b508      	push	{r3, lr}
	ili9341_SetupPorts();	// Configurar os pinos de controle
    3a4c:	6813      	ldr	r3, [r2, #0]
    3a4e:	f443 2380 	orr.w	r3, r3, #262144	; 0x40000
    3a52:	6013      	str	r3, [r2, #0]
    3a54:	4b89      	ldr	r3, [pc, #548]	; (3c7c <tft_Init+0x234>)
    3a56:	681a      	ldr	r2, [r3, #0]
    3a58:	f042 0202 	orr.w	r2, r2, #2
    3a5c:	601a      	str	r2, [r3, #0]
    3a5e:	681a      	ldr	r2, [r3, #0]
    3a60:	f042 0201 	orr.w	r2, r2, #1
    3a64:	601a      	str	r2, [r3, #0]

	#if (ILI9341_USE_RESET == pdON)
	tft_Reset();
    3a66:	f7ff ffaf 	bl	39c8 <tft_Reset>
	#endif

  	tft_WriteCommand(0xEF);
    3a6a:	20ef      	movs	r0, #239	; 0xef
    3a6c:	f7ff ffc8 	bl	3a00 <tft_WriteCommand>
  	tft_WriteData(0x03);
    3a70:	2003      	movs	r0, #3
    3a72:	f7ff ffd7 	bl	3a24 <tft_WriteData>
  	tft_WriteData(0x80);
    3a76:	2080      	movs	r0, #128	; 0x80
    3a78:	f7ff ffd4 	bl	3a24 <tft_WriteData>
  	tft_WriteData(0x02);
    3a7c:	2002      	movs	r0, #2
    3a7e:	f7ff ffd1 	bl	3a24 <tft_WriteData>

 	tft_WriteCommand(0xCF);
    3a82:	20cf      	movs	r0, #207	; 0xcf
    3a84:	f7ff ffbc 	bl	3a00 <tft_WriteCommand>
  	tft_WriteData(0x00);
    3a88:	2000      	movs	r0, #0
    3a8a:	f7ff ffcb 	bl	3a24 <tft_WriteData>
  	tft_WriteData(0XC1);
    3a8e:	20c1      	movs	r0, #193	; 0xc1
    3a90:	f7ff ffc8 	bl	3a24 <tft_WriteData>
  	tft_WriteData(0X30);
    3a94:	2030      	movs	r0, #48	; 0x30
    3a96:	f7ff ffc5 	bl	3a24 <tft_WriteData>

  	tft_WriteCommand(0xED);
    3a9a:	20ed      	movs	r0, #237	; 0xed
    3a9c:	f7ff ffb0 	bl	3a00 <tft_WriteCommand>
  	tft_WriteData(0x64);
    3aa0:	2064      	movs	r0, #100	; 0x64
    3aa2:	f7ff ffbf 	bl	3a24 <tft_WriteData>
  	tft_WriteData(0x03);
    3aa6:	2003      	movs	r0, #3
    3aa8:	f7ff ffbc 	bl	3a24 <tft_WriteData>
  	tft_WriteData(0X12);
    3aac:	2012      	movs	r0, #18
    3aae:	f7ff ffb9 	bl	3a24 <tft_WriteData>
  	tft_WriteData(0X81);
    3ab2:	2081      	movs	r0, #129	; 0x81
    3ab4:	f7ff ffb6 	bl	3a24 <tft_WriteData>

  	tft_WriteCommand(0xE8);
    3ab8:	20e8      	movs	r0, #232	; 0xe8
    3aba:	f7ff ffa1 	bl	3a00 <tft_WriteCommand>
  	tft_WriteData(0x85);
    3abe:	2085      	movs	r0, #133	; 0x85
    3ac0:	f7ff ffb0 	bl	3a24 <tft_WriteData>
  	tft_WriteData(0x00);
    3ac4:	2000      	movs	r0, #0
    3ac6:	f7ff ffad 	bl	3a24 <tft_WriteData>
  	tft_WriteData(0x78);
    3aca:	2078      	movs	r0, #120	; 0x78
    3acc:	f7ff ffaa 	bl	3a24 <tft_WriteData>

  	tft_WriteCommand(0xCB);
    3ad0:	20cb      	movs	r0, #203	; 0xcb
    3ad2:	f7ff ff95 	bl	3a00 <tft_WriteCommand>
  	tft_WriteData(0x39);
    3ad6:	2039      	movs	r0, #57	; 0x39
    3ad8:	f7ff ffa4 	bl	3a24 <tft_WriteData>
  	tft_WriteData(0x2C);
    3adc:	202c      	movs	r0, #44	; 0x2c
    3ade:	f7ff ffa1 	bl	3a24 <tft_WriteData>
  	tft_WriteData(0x00);
    3ae2:	2000      	movs	r0, #0
    3ae4:	f7ff ff9e 	bl	3a24 <tft_WriteData>
  	tft_WriteData(0x34);
    3ae8:	2034      	movs	r0, #52	; 0x34
    3aea:	f7ff ff9b 	bl	3a24 <tft_WriteData>
  	tft_WriteData(0x02);
    3aee:	2002      	movs	r0, #2
    3af0:	f7ff ff98 	bl	3a24 <tft_WriteData>

  	tft_WriteCommand(0xF7);
    3af4:	20f7      	movs	r0, #247	; 0xf7
    3af6:	f7ff ff83 	bl	3a00 <tft_WriteCommand>
  	tft_WriteData(0x20);
    3afa:	2020      	movs	r0, #32
    3afc:	f7ff ff92 	bl	3a24 <tft_WriteData>

  	tft_WriteCommand(0xEA);
    3b00:	20ea      	movs	r0, #234	; 0xea
    3b02:	f7ff ff7d 	bl	3a00 <tft_WriteCommand>
  	tft_WriteData(0x00);
    3b06:	2000      	movs	r0, #0
    3b08:	f7ff ff8c 	bl	3a24 <tft_WriteData>
  	tft_WriteData(0x00);
    3b0c:	2000      	movs	r0, #0
    3b0e:	f7ff ff89 	bl	3a24 <tft_WriteData>

  	tft_WriteCommand(ILI9341_PWCTR1);    //Power control
    3b12:	20c0      	movs	r0, #192	; 0xc0
    3b14:	f7ff ff74 	bl	3a00 <tft_WriteCommand>
  	tft_WriteData(0x23);   //VRH[5:0]
    3b18:	2023      	movs	r0, #35	; 0x23
    3b1a:	f7ff ff83 	bl	3a24 <tft_WriteData>

  	tft_WriteCommand(ILI9341_PWCTR2);    //Power control
    3b1e:	20c1      	movs	r0, #193	; 0xc1
    3b20:	f7ff ff6e 	bl	3a00 <tft_WriteCommand>
  	tft_WriteData(0x10);   //SAP[2:0];BT[3:0]
    3b24:	2010      	movs	r0, #16
    3b26:	f7ff ff7d 	bl	3a24 <tft_WriteData>

  	tft_WriteCommand(ILI9341_VMCTR1);    //VCM control
    3b2a:	20c5      	movs	r0, #197	; 0xc5
    3b2c:	f7ff ff68 	bl	3a00 <tft_WriteCommand>
  	tft_WriteData(0x3e); //Â¶Ã”Â±ÃˆÂ¶ÃˆÂµÃ·Â½Ãš
    3b30:	203e      	movs	r0, #62	; 0x3e
    3b32:	f7ff ff77 	bl	3a24 <tft_WriteData>
  	tft_WriteData(0x28);
    3b36:	2028      	movs	r0, #40	; 0x28
    3b38:	f7ff ff74 	bl	3a24 <tft_WriteData>

  	tft_WriteCommand(ILI9341_VMCTR2);    //VCM control2
    3b3c:	20c7      	movs	r0, #199	; 0xc7
    3b3e:	f7ff ff5f 	bl	3a00 <tft_WriteCommand>
  	tft_WriteData(0x86);  //--
    3b42:	2086      	movs	r0, #134	; 0x86
    3b44:	f7ff ff6e 	bl	3a24 <tft_WriteData>

  	tft_WriteCommand(ILI9341_MADCTL);    // Memory Access Control
    3b48:	2036      	movs	r0, #54	; 0x36
    3b4a:	f7ff ff59 	bl	3a00 <tft_WriteCommand>
  	tft_WriteData(0x48);
    3b4e:	2048      	movs	r0, #72	; 0x48
    3b50:	f7ff ff68 	bl	3a24 <tft_WriteData>

  	tft_WriteCommand(ILI9341_PIXFMT);
    3b54:	203a      	movs	r0, #58	; 0x3a
    3b56:	f7ff ff53 	bl	3a00 <tft_WriteCommand>
  	tft_WriteData(0x55);
    3b5a:	2055      	movs	r0, #85	; 0x55
    3b5c:	f7ff ff62 	bl	3a24 <tft_WriteData>

  	tft_WriteCommand(ILI9341_FRMCTR1);
    3b60:	20b1      	movs	r0, #177	; 0xb1
    3b62:	f7ff ff4d 	bl	3a00 <tft_WriteCommand>
  	tft_WriteData(0x00);
    3b66:	2000      	movs	r0, #0
    3b68:	f7ff ff5c 	bl	3a24 <tft_WriteData>
  	tft_WriteData(0x18);
    3b6c:	2018      	movs	r0, #24
    3b6e:	f7ff ff59 	bl	3a24 <tft_WriteData>

  	tft_WriteCommand(ILI9341_DFUNCTR);    // Display Function Control
    3b72:	20b6      	movs	r0, #182	; 0xb6
    3b74:	f7ff ff44 	bl	3a00 <tft_WriteCommand>
  	tft_WriteData(0x08);
    3b78:	2008      	movs	r0, #8
    3b7a:	f7ff ff53 	bl	3a24 <tft_WriteData>
  	tft_WriteData(0x82);
    3b7e:	2082      	movs	r0, #130	; 0x82
    3b80:	f7ff ff50 	bl	3a24 <tft_WriteData>
  	tft_WriteData(0x27);
    3b84:	2027      	movs	r0, #39	; 0x27
    3b86:	f7ff ff4d 	bl	3a24 <tft_WriteData>

  	tft_WriteCommand(0xF2);    // 3Gamma Function Disable
    3b8a:	20f2      	movs	r0, #242	; 0xf2
    3b8c:	f7ff ff38 	bl	3a00 <tft_WriteCommand>
  	tft_WriteData(0x00);
    3b90:	2000      	movs	r0, #0
    3b92:	f7ff ff47 	bl	3a24 <tft_WriteData>

  	tft_WriteCommand(ILI9341_GAMMASET);    //Gamma curve selected
    3b96:	2026      	movs	r0, #38	; 0x26
    3b98:	f7ff ff32 	bl	3a00 <tft_WriteCommand>
  	tft_WriteData(0x01);
    3b9c:	2001      	movs	r0, #1
    3b9e:	f7ff ff41 	bl	3a24 <tft_WriteData>

  	tft_WriteCommand(ILI9341_GMCTRP1);    //Set Gamma
    3ba2:	20e0      	movs	r0, #224	; 0xe0
    3ba4:	f7ff ff2c 	bl	3a00 <tft_WriteCommand>
  	tft_WriteData(0x0F);
    3ba8:	200f      	movs	r0, #15
    3baa:	f7ff ff3b 	bl	3a24 <tft_WriteData>
  	tft_WriteData(0x31);
    3bae:	2031      	movs	r0, #49	; 0x31
    3bb0:	f7ff ff38 	bl	3a24 <tft_WriteData>
  	tft_WriteData(0x2B);
    3bb4:	202b      	movs	r0, #43	; 0x2b
    3bb6:	f7ff ff35 	bl	3a24 <tft_WriteData>
  	tft_WriteData(0x0C);
    3bba:	200c      	movs	r0, #12
    3bbc:	f7ff ff32 	bl	3a24 <tft_WriteData>
  	tft_WriteData(0x0E);
    3bc0:	200e      	movs	r0, #14
    3bc2:	f7ff ff2f 	bl	3a24 <tft_WriteData>
  	tft_WriteData(0x08);
    3bc6:	2008      	movs	r0, #8
    3bc8:	f7ff ff2c 	bl	3a24 <tft_WriteData>
  	tft_WriteData(0x4E);
    3bcc:	204e      	movs	r0, #78	; 0x4e
    3bce:	f7ff ff29 	bl	3a24 <tft_WriteData>
  	tft_WriteData(0xF1);
    3bd2:	20f1      	movs	r0, #241	; 0xf1
    3bd4:	f7ff ff26 	bl	3a24 <tft_WriteData>
  	tft_WriteData(0x37);
    3bd8:	2037      	movs	r0, #55	; 0x37
    3bda:	f7ff ff23 	bl	3a24 <tft_WriteData>
  	tft_WriteData(0x07);
    3bde:	2007      	movs	r0, #7
    3be0:	f7ff ff20 	bl	3a24 <tft_WriteData>
  	tft_WriteData(0x10);
    3be4:	2010      	movs	r0, #16
    3be6:	f7ff ff1d 	bl	3a24 <tft_WriteData>
  	tft_WriteData(0x03);
    3bea:	2003      	movs	r0, #3
    3bec:	f7ff ff1a 	bl	3a24 <tft_WriteData>
  	tft_WriteData(0x0E);
    3bf0:	200e      	movs	r0, #14
    3bf2:	f7ff ff17 	bl	3a24 <tft_WriteData>
  	tft_WriteData(0x09);
    3bf6:	2009      	movs	r0, #9
    3bf8:	f7ff ff14 	bl	3a24 <tft_WriteData>
  	tft_WriteData(0x00);
    3bfc:	2000      	movs	r0, #0
    3bfe:	f7ff ff11 	bl	3a24 <tft_WriteData>

  	tft_WriteCommand(ILI9341_GMCTRN1);    //Set Gamma
    3c02:	20e1      	movs	r0, #225	; 0xe1
    3c04:	f7ff fefc 	bl	3a00 <tft_WriteCommand>
  	tft_WriteData(0x00);
    3c08:	2000      	movs	r0, #0
    3c0a:	f7ff ff0b 	bl	3a24 <tft_WriteData>
  	tft_WriteData(0x0E);
    3c0e:	200e      	movs	r0, #14
    3c10:	f7ff ff08 	bl	3a24 <tft_WriteData>
  	tft_WriteData(0x14);
    3c14:	2014      	movs	r0, #20
    3c16:	f7ff ff05 	bl	3a24 <tft_WriteData>
  	tft_WriteData(0x03);
    3c1a:	2003      	movs	r0, #3
    3c1c:	f7ff ff02 	bl	3a24 <tft_WriteData>
  	tft_WriteData(0x11);
    3c20:	2011      	movs	r0, #17
    3c22:	f7ff feff 	bl	3a24 <tft_WriteData>
  	tft_WriteData(0x07);
    3c26:	2007      	movs	r0, #7
    3c28:	f7ff fefc 	bl	3a24 <tft_WriteData>
  	tft_WriteData(0x31);
    3c2c:	2031      	movs	r0, #49	; 0x31
    3c2e:	f7ff fef9 	bl	3a24 <tft_WriteData>
  	tft_WriteData(0xC1);
    3c32:	20c1      	movs	r0, #193	; 0xc1
    3c34:	f7ff fef6 	bl	3a24 <tft_WriteData>
  	tft_WriteData(0x48);
    3c38:	2048      	movs	r0, #72	; 0x48
    3c3a:	f7ff fef3 	bl	3a24 <tft_WriteData>
  	tft_WriteData(0x08);
    3c3e:	2008      	movs	r0, #8
    3c40:	f7ff fef0 	bl	3a24 <tft_WriteData>
  	tft_WriteData(0x0F);
    3c44:	200f      	movs	r0, #15
    3c46:	f7ff feed 	bl	3a24 <tft_WriteData>
  	tft_WriteData(0x0C);
    3c4a:	200c      	movs	r0, #12
    3c4c:	f7ff feea 	bl	3a24 <tft_WriteData>
  	tft_WriteData(0x31);
    3c50:	2031      	movs	r0, #49	; 0x31
    3c52:	f7ff fee7 	bl	3a24 <tft_WriteData>
  	tft_WriteData(0x36);
    3c56:	2036      	movs	r0, #54	; 0x36
    3c58:	f7ff fee4 	bl	3a24 <tft_WriteData>
  	tft_WriteData(0x0F);
    3c5c:	200f      	movs	r0, #15
    3c5e:	f7ff fee1 	bl	3a24 <tft_WriteData>

  	tft_WriteCommand(ILI9341_SLPOUT);    //Exit Sleep
    3c62:	2011      	movs	r0, #17
    3c64:	f7ff fecc 	bl	3a00 <tft_WriteCommand>
  	delay_ms(120);
    3c68:	4805      	ldr	r0, [pc, #20]	; (3c80 <tft_Init+0x238>)
    3c6a:	f7fd ff83 	bl	1b74 <delay>
  	tft_WriteCommand(ILI9341_DISPON);    //Display on
}
    3c6e:	e8bd 4008 	ldmia.w	sp!, {r3, lr}
  	tft_WriteData(0x36);
  	tft_WriteData(0x0F);

  	tft_WriteCommand(ILI9341_SLPOUT);    //Exit Sleep
  	delay_ms(120);
  	tft_WriteCommand(ILI9341_DISPON);    //Display on
    3c72:	2029      	movs	r0, #41	; 0x29
    3c74:	f7ff bec4 	b.w	3a00 <tft_WriteCommand>
    3c78:	2009c000 	.word	0x2009c000
    3c7c:	2009c040 	.word	0x2009c040
    3c80:	003d0900 	.word	0x003d0900

Disassembly of section .text.tft_SetAddrWindow:

00003c84 <tft_SetAddrWindow>:
}

//##################################################################################################################
//
//##################################################################################################################
void tft_SetAddrWindow(u16 x0, u16 y0, u16 x1, u16 y1) {
    3c84:	b5f8      	push	{r3, r4, r5, r6, r7, lr}
    3c86:	4607      	mov	r7, r0
    3c88:	4616      	mov	r6, r2
    3c8a:	460d      	mov	r5, r1
    3c8c:	461c      	mov	r4, r3

  tft_WriteCommand(ILI9341_CASET); // Column addr set
    3c8e:	202a      	movs	r0, #42	; 0x2a
    3c90:	f7ff feb6 	bl	3a00 <tft_WriteCommand>
  tft_WriteData(x0 >> 8);
    3c94:	0a38      	lsrs	r0, r7, #8
    3c96:	f7ff fec5 	bl	3a24 <tft_WriteData>
  tft_WriteData(x0 & 0xFF);     // XSTART
    3c9a:	b2f8      	uxtb	r0, r7
    3c9c:	f7ff fec2 	bl	3a24 <tft_WriteData>
  tft_WriteData(x1 >> 8);
    3ca0:	0a30      	lsrs	r0, r6, #8
    3ca2:	f7ff febf 	bl	3a24 <tft_WriteData>
  tft_WriteData(x1 & 0xFF);     // XEND
    3ca6:	b2f0      	uxtb	r0, r6
    3ca8:	f7ff febc 	bl	3a24 <tft_WriteData>

  tft_WriteCommand(ILI9341_PASET); // Row addr set
    3cac:	202b      	movs	r0, #43	; 0x2b
    3cae:	f7ff fea7 	bl	3a00 <tft_WriteCommand>
  tft_WriteData(y0>>8);
    3cb2:	0a28      	lsrs	r0, r5, #8
    3cb4:	f7ff feb6 	bl	3a24 <tft_WriteData>
  tft_WriteData(y0);     // YSTART
    3cb8:	b2e8      	uxtb	r0, r5
    3cba:	f7ff feb3 	bl	3a24 <tft_WriteData>
  tft_WriteData(y1>>8);
    3cbe:	0a20      	lsrs	r0, r4, #8
    3cc0:	f7ff feb0 	bl	3a24 <tft_WriteData>
  tft_WriteData(y1);     // YEND
    3cc4:	b2e0      	uxtb	r0, r4
    3cc6:	f7ff fead 	bl	3a24 <tft_WriteData>

  tft_WriteCommand(ILI9341_RAMWR); // write to RAM
}
    3cca:	e8bd 40f8 	ldmia.w	sp!, {r3, r4, r5, r6, r7, lr}
  tft_WriteData(y0>>8);
  tft_WriteData(y0);     // YSTART
  tft_WriteData(y1>>8);
  tft_WriteData(y1);     // YEND

  tft_WriteCommand(ILI9341_RAMWR); // write to RAM
    3cce:	202c      	movs	r0, #44	; 0x2c
    3cd0:	f7ff be96 	b.w	3a00 <tft_WriteCommand>

Disassembly of section .text.tft_DrawPixel:

00003cd4 <tft_DrawPixel>:
  	ili9341_TransferByte(color);
  	ili9341_Disable();
}

void tft_DrawPixel(s16 x, s16 y, u16 color) {
	if((x < 0) ||(x >= _width) || (y < 0) || (y >= _height)) return;
    3cd4:	2800      	cmp	r0, #0
  	ili9341_TransferByte(color >> 8);
  	ili9341_TransferByte(color);
  	ili9341_Disable();
}

void tft_DrawPixel(s16 x, s16 y, u16 color) {
    3cd6:	b538      	push	{r3, r4, r5, lr}
    3cd8:	4615      	mov	r5, r2
	if((x < 0) ||(x >= _width) || (y < 0) || (y >= _height)) return;
    3cda:	db20      	blt.n	3d1e <tft_DrawPixel+0x4a>
    3cdc:	4b10      	ldr	r3, [pc, #64]	; (3d20 <tft_DrawPixel+0x4c>)
    3cde:	881b      	ldrh	r3, [r3, #0]
    3ce0:	4298      	cmp	r0, r3
    3ce2:	da1c      	bge.n	3d1e <tft_DrawPixel+0x4a>
    3ce4:	2900      	cmp	r1, #0
    3ce6:	db1a      	blt.n	3d1e <tft_DrawPixel+0x4a>
    3ce8:	4b0e      	ldr	r3, [pc, #56]	; (3d24 <tft_DrawPixel+0x50>)
    3cea:	881b      	ldrh	r3, [r3, #0]
    3cec:	4299      	cmp	r1, r3
    3cee:	da16      	bge.n	3d1e <tft_DrawPixel+0x4a>

  	tft_SetAddrWindow(x,y,x+1,y+1);
    3cf0:	b289      	uxth	r1, r1
    3cf2:	b280      	uxth	r0, r0
    3cf4:	1c4b      	adds	r3, r1, #1
    3cf6:	1c42      	adds	r2, r0, #1
    3cf8:	b29b      	uxth	r3, r3
    3cfa:	b292      	uxth	r2, r2
    3cfc:	f7ff ffc2 	bl	3c84 <tft_SetAddrWindow>

  	ili9341_Data();
    3d00:	4b09      	ldr	r3, [pc, #36]	; (3d28 <tft_DrawPixel+0x54>)
    3d02:	2202      	movs	r2, #2
  	ili9341_Enable();
    3d04:	f44f 2480 	mov.w	r4, #262144	; 0x40000
void tft_DrawPixel(s16 x, s16 y, u16 color) {
	if((x < 0) ||(x >= _width) || (y < 0) || (y >= _height)) return;

  	tft_SetAddrWindow(x,y,x+1,y+1);

  	ili9341_Data();
    3d08:	601a      	str	r2, [r3, #0]
  	ili9341_Enable();
  	ili9341_TransferByte(color >> 8);
    3d0a:	0a28      	lsrs	r0, r5, #8
	if((x < 0) ||(x >= _width) || (y < 0) || (y >= _height)) return;

  	tft_SetAddrWindow(x,y,x+1,y+1);

  	ili9341_Data();
  	ili9341_Enable();
    3d0c:	f843 4c3c 	str.w	r4, [r3, #-60]
  	ili9341_TransferByte(color >> 8);
    3d10:	f7fe f914 	bl	1f3c <ssp1_TransferByte>
  	ili9341_TransferByte(color);
    3d14:	b2e8      	uxtb	r0, r5
    3d16:	f7fe f911 	bl	1f3c <ssp1_TransferByte>
	ili9341_Disable();
    3d1a:	4b04      	ldr	r3, [pc, #16]	; (3d2c <tft_DrawPixel+0x58>)
    3d1c:	601c      	str	r4, [r3, #0]
    3d1e:	bd38      	pop	{r3, r4, r5, pc}
    3d20:	10000040 	.word	0x10000040
    3d24:	1000003e 	.word	0x1000003e
    3d28:	2009c058 	.word	0x2009c058
    3d2c:	2009c018 	.word	0x2009c018

Disassembly of section .text.tft_DrawFastVLine:

00003d30 <tft_DrawFastVLine>:
}

void tft_DrawFastVLine(s16 x, s16 y, s16 h, u16 color) {
    3d30:	b570      	push	{r4, r5, r6, lr}
    3d32:	461d      	mov	r5, r3
  	// Rudimentary clipping
  	if((x >= _width) || (y >= _height)) return;
    3d34:	4b16      	ldr	r3, [pc, #88]	; (3d90 <tft_DrawFastVLine+0x60>)
    3d36:	881b      	ldrh	r3, [r3, #0]
    3d38:	4298      	cmp	r0, r3
    3d3a:	da28      	bge.n	3d8e <tft_DrawFastVLine+0x5e>
    3d3c:	4b15      	ldr	r3, [pc, #84]	; (3d94 <tft_DrawFastVLine+0x64>)
    3d3e:	881b      	ldrh	r3, [r3, #0]
    3d40:	4299      	cmp	r1, r3
    3d42:	da24      	bge.n	3d8e <tft_DrawFastVLine+0x5e>

  	if((y+h-1) >= _height) h = _height-y;
    3d44:	1854      	adds	r4, r2, r1
    3d46:	42a3      	cmp	r3, r4
    3d48:	bfbc      	itt	lt
    3d4a:	1a5b      	sublt	r3, r3, r1
    3d4c:	b21a      	sxthlt	r2, r3
  	tft_SetAddrWindow(x, y, x, y+h-1);
    3d4e:	b289      	uxth	r1, r1
    3d50:	b294      	uxth	r4, r2
    3d52:	1e4b      	subs	r3, r1, #1
    3d54:	b280      	uxth	r0, r0
    3d56:	4423      	add	r3, r4
    3d58:	b29b      	uxth	r3, r3
    3d5a:	4602      	mov	r2, r0
    3d5c:	f7ff ff92 	bl	3c84 <tft_SetAddrWindow>

  	u8 hi = color >> 8, lo = color;

 	ili9341_Data();
    3d60:	4b0d      	ldr	r3, [pc, #52]	; (3d98 <tft_DrawFastVLine+0x68>)
    3d62:	2202      	movs	r2, #2
    3d64:	601a      	str	r2, [r3, #0]
  	ili9341_Enable();
    3d66:	f44f 2280 	mov.w	r2, #262144	; 0x40000
  	if((x >= _width) || (y >= _height)) return;

  	if((y+h-1) >= _height) h = _height-y;
  	tft_SetAddrWindow(x, y, x, y+h-1);

  	u8 hi = color >> 8, lo = color;
    3d6a:	0a2e      	lsrs	r6, r5, #8

 	ili9341_Data();
  	ili9341_Enable();
    3d6c:	f843 2c3c 	str.w	r2, [r3, #-60]
  	if((x >= _width) || (y >= _height)) return;

  	if((y+h-1) >= _height) h = _height-y;
  	tft_SetAddrWindow(x, y, x, y+h-1);

  	u8 hi = color >> 8, lo = color;
    3d70:	b2ed      	uxtb	r5, r5

 	ili9341_Data();
  	ili9341_Enable();
  	while (h--) {
    3d72:	b144      	cbz	r4, 3d86 <tft_DrawFastVLine+0x56>
    	ili9341_TransferByte(hi);
    3d74:	4630      	mov	r0, r6
    3d76:	f7fe f8e1 	bl	1f3c <ssp1_TransferByte>
    3d7a:	3c01      	subs	r4, #1
    	ili9341_TransferByte(lo);
    3d7c:	4628      	mov	r0, r5
    3d7e:	f7fe f8dd 	bl	1f3c <ssp1_TransferByte>
    3d82:	b2a4      	uxth	r4, r4
    3d84:	e7f5      	b.n	3d72 <tft_DrawFastVLine+0x42>
  	}
  	ili9341_Disable();
    3d86:	4b05      	ldr	r3, [pc, #20]	; (3d9c <tft_DrawFastVLine+0x6c>)
    3d88:	f44f 2280 	mov.w	r2, #262144	; 0x40000
    3d8c:	601a      	str	r2, [r3, #0]
    3d8e:	bd70      	pop	{r4, r5, r6, pc}
    3d90:	10000040 	.word	0x10000040
    3d94:	1000003e 	.word	0x1000003e
    3d98:	2009c058 	.word	0x2009c058
    3d9c:	2009c018 	.word	0x2009c018

Disassembly of section .text.tft_DrawFastHLine:

00003da0 <tft_DrawFastHLine>:
}

void tft_DrawFastHLine(s16 x, s16 y, s16 w, u16 color) {
    3da0:	b570      	push	{r4, r5, r6, lr}
    3da2:	461e      	mov	r6, r3
  	if((x >= _width) || (y >= _height)) return;
    3da4:	4b16      	ldr	r3, [pc, #88]	; (3e00 <tft_DrawFastHLine+0x60>)
    3da6:	881d      	ldrh	r5, [r3, #0]
    3da8:	42a8      	cmp	r0, r5
    3daa:	da28      	bge.n	3dfe <tft_DrawFastHLine+0x5e>
    3dac:	4b15      	ldr	r3, [pc, #84]	; (3e04 <tft_DrawFastHLine+0x64>)
    3dae:	881b      	ldrh	r3, [r3, #0]
    3db0:	4299      	cmp	r1, r3
    3db2:	da24      	bge.n	3dfe <tft_DrawFastHLine+0x5e>
  	if((x+w-1) >= _width)  w = _width-x;
    3db4:	1813      	adds	r3, r2, r0
    3db6:	429d      	cmp	r5, r3
    3db8:	bfbc      	itt	lt
    3dba:	1a2d      	sublt	r5, r5, r0
    3dbc:	b22a      	sxthlt	r2, r5
  	tft_SetAddrWindow(x, y, x+w-1, y);
    3dbe:	b280      	uxth	r0, r0
    3dc0:	b294      	uxth	r4, r2
    3dc2:	1e42      	subs	r2, r0, #1
    3dc4:	b28b      	uxth	r3, r1
    3dc6:	4422      	add	r2, r4
    3dc8:	b292      	uxth	r2, r2
    3dca:	4619      	mov	r1, r3
    3dcc:	f7ff ff5a 	bl	3c84 <tft_SetAddrWindow>

  	u8 hi = color >> 8, lo = color;
  	ili9341_Data();
    3dd0:	4b0d      	ldr	r3, [pc, #52]	; (3e08 <tft_DrawFastHLine+0x68>)
    3dd2:	2202      	movs	r2, #2
    3dd4:	601a      	str	r2, [r3, #0]
  	ili9341_Enable();
    3dd6:	f44f 2280 	mov.w	r2, #262144	; 0x40000
void tft_DrawFastHLine(s16 x, s16 y, s16 w, u16 color) {
  	if((x >= _width) || (y >= _height)) return;
  	if((x+w-1) >= _width)  w = _width-x;
  	tft_SetAddrWindow(x, y, x+w-1, y);

  	u8 hi = color >> 8, lo = color;
    3dda:	0a35      	lsrs	r5, r6, #8
  	ili9341_Data();
  	ili9341_Enable();
    3ddc:	f843 2c3c 	str.w	r2, [r3, #-60]
void tft_DrawFastHLine(s16 x, s16 y, s16 w, u16 color) {
  	if((x >= _width) || (y >= _height)) return;
  	if((x+w-1) >= _width)  w = _width-x;
  	tft_SetAddrWindow(x, y, x+w-1, y);

  	u8 hi = color >> 8, lo = color;
    3de0:	b2f6      	uxtb	r6, r6
  	ili9341_Data();
  	ili9341_Enable();
  	while (w--) {
    3de2:	b144      	cbz	r4, 3df6 <tft_DrawFastHLine+0x56>
    	ili9341_TransferByte(hi);
    3de4:	4628      	mov	r0, r5
    3de6:	f7fe f8a9 	bl	1f3c <ssp1_TransferByte>
    3dea:	3c01      	subs	r4, #1
    	ili9341_TransferByte(lo);
    3dec:	4630      	mov	r0, r6
    3dee:	f7fe f8a5 	bl	1f3c <ssp1_TransferByte>
    3df2:	b2a4      	uxth	r4, r4
    3df4:	e7f5      	b.n	3de2 <tft_DrawFastHLine+0x42>
  	}
  	ili9341_Disable();
    3df6:	4b05      	ldr	r3, [pc, #20]	; (3e0c <tft_DrawFastHLine+0x6c>)
    3df8:	f44f 2280 	mov.w	r2, #262144	; 0x40000
    3dfc:	601a      	str	r2, [r3, #0]
    3dfe:	bd70      	pop	{r4, r5, r6, pc}
    3e00:	10000040 	.word	0x10000040
    3e04:	1000003e 	.word	0x1000003e
    3e08:	2009c058 	.word	0x2009c058
    3e0c:	2009c018 	.word	0x2009c018

Disassembly of section .text.tft_FillRect:

00003e10 <tft_FillRect>:
void tft_FillScreen(u16 color) {
  	tft_FillRect(0, 0,  _width, _height, color);
}

// fill a rectangle
void tft_FillRect(s16 x, s16 y, s16 w, s16 h, u16 color) {
    3e10:	e92d 41f0 	stmdb	sp!, {r4, r5, r6, r7, r8, lr}
    3e14:	461c      	mov	r4, r3
  	// rudimentary clipping (drawChar w/big text requires this)
  	if((x >= _width) || (y >= _height)) return;
    3e16:	4b21      	ldr	r3, [pc, #132]	; (3e9c <tft_FillRect+0x8c>)
void tft_FillScreen(u16 color) {
  	tft_FillRect(0, 0,  _width, _height, color);
}

// fill a rectangle
void tft_FillRect(s16 x, s16 y, s16 w, s16 h, u16 color) {
    3e18:	4615      	mov	r5, r2
  	// rudimentary clipping (drawChar w/big text requires this)
  	if((x >= _width) || (y >= _height)) return;
    3e1a:	881a      	ldrh	r2, [r3, #0]
void tft_FillScreen(u16 color) {
  	tft_FillRect(0, 0,  _width, _height, color);
}

// fill a rectangle
void tft_FillRect(s16 x, s16 y, s16 w, s16 h, u16 color) {
    3e1c:	f8bd 6018 	ldrh.w	r6, [sp, #24]
  	// rudimentary clipping (drawChar w/big text requires this)
  	if((x >= _width) || (y >= _height)) return;
    3e20:	4290      	cmp	r0, r2
    3e22:	da39      	bge.n	3e98 <tft_FillRect+0x88>
    3e24:	4b1e      	ldr	r3, [pc, #120]	; (3ea0 <tft_FillRect+0x90>)
    3e26:	881b      	ldrh	r3, [r3, #0]
    3e28:	4299      	cmp	r1, r3
    3e2a:	da35      	bge.n	3e98 <tft_FillRect+0x88>
  	if((x + w - 1) >= _width)  w = _width  - x;
    3e2c:	182f      	adds	r7, r5, r0
    3e2e:	42ba      	cmp	r2, r7
    3e30:	bfb8      	it	lt
    3e32:	1a15      	sublt	r5, r2, r0
  	if((y + h - 1) >= _height) h = _height - y;
    3e34:	eb04 0201 	add.w	r2, r4, r1

// fill a rectangle
void tft_FillRect(s16 x, s16 y, s16 w, s16 h, u16 color) {
  	// rudimentary clipping (drawChar w/big text requires this)
  	if((x >= _width) || (y >= _height)) return;
  	if((x + w - 1) >= _width)  w = _width  - x;
    3e38:	bfb8      	it	lt
    3e3a:	b22d      	sxthlt	r5, r5
  	if((y + h - 1) >= _height) h = _height - y;
    3e3c:	4293      	cmp	r3, r2
    3e3e:	bfb8      	it	lt
    3e40:	1a5c      	sublt	r4, r3, r1

  	tft_SetAddrWindow(x, y, x+w-1, y+h-1);
    3e42:	b280      	uxth	r0, r0
    3e44:	b289      	uxth	r1, r1
// fill a rectangle
void tft_FillRect(s16 x, s16 y, s16 w, s16 h, u16 color) {
  	// rudimentary clipping (drawChar w/big text requires this)
  	if((x >= _width) || (y >= _height)) return;
  	if((x + w - 1) >= _width)  w = _width  - x;
  	if((y + h - 1) >= _height) h = _height - y;
    3e46:	bfb8      	it	lt
    3e48:	b224      	sxthlt	r4, r4

  	tft_SetAddrWindow(x, y, x+w-1, y+h-1);
    3e4a:	1e4b      	subs	r3, r1, #1
    3e4c:	1e42      	subs	r2, r0, #1
    3e4e:	4423      	add	r3, r4
    3e50:	442a      	add	r2, r5
    3e52:	b29b      	uxth	r3, r3
    3e54:	b292      	uxth	r2, r2
    3e56:	f7ff ff15 	bl	3c84 <tft_SetAddrWindow>

  	u8 hi = color >> 8, lo = color;

  	ili9341_Data();
    3e5a:	4b12      	ldr	r3, [pc, #72]	; (3ea4 <tft_FillRect+0x94>)
    3e5c:	2202      	movs	r2, #2
    3e5e:	601a      	str	r2, [r3, #0]
  	ili9341_Enable();
    3e60:	f44f 2280 	mov.w	r2, #262144	; 0x40000
  	if((x + w - 1) >= _width)  w = _width  - x;
  	if((y + h - 1) >= _height) h = _height - y;

  	tft_SetAddrWindow(x, y, x+w-1, y+h-1);

  	u8 hi = color >> 8, lo = color;
    3e64:	0a37      	lsrs	r7, r6, #8
    3e66:	fa5f f886 	uxtb.w	r8, r6

  	ili9341_Data();
  	ili9341_Enable();
    3e6a:	f843 2c3c 	str.w	r2, [r3, #-60]
  	for(y=h; y>0; y--) {
    3e6e:	2c00      	cmp	r4, #0
    3e70:	dd0e      	ble.n	3e90 <tft_FillRect+0x80>
    3e72:	462e      	mov	r6, r5
    	for(x=w; x>0; x--) {
    3e74:	2e00      	cmp	r6, #0
    3e76:	dd08      	ble.n	3e8a <tft_FillRect+0x7a>
      		ili9341_TransferByte(hi);
    3e78:	4638      	mov	r0, r7
    3e7a:	f7fe f85f 	bl	1f3c <ssp1_TransferByte>
    3e7e:	3e01      	subs	r6, #1
      		ili9341_TransferByte(lo);
    3e80:	4640      	mov	r0, r8
    3e82:	f7fe f85b 	bl	1f3c <ssp1_TransferByte>
    3e86:	b236      	sxth	r6, r6
    3e88:	e7f4      	b.n	3e74 <tft_FillRect+0x64>
    3e8a:	3c01      	subs	r4, #1
    3e8c:	b224      	sxth	r4, r4
    3e8e:	e7ee      	b.n	3e6e <tft_FillRect+0x5e>
    	}
  	}
  	ili9341_Disable();
    3e90:	4b05      	ldr	r3, [pc, #20]	; (3ea8 <tft_FillRect+0x98>)
    3e92:	f44f 2280 	mov.w	r2, #262144	; 0x40000
    3e96:	601a      	str	r2, [r3, #0]
    3e98:	e8bd 81f0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, pc}
    3e9c:	10000040 	.word	0x10000040
    3ea0:	1000003e 	.word	0x1000003e
    3ea4:	2009c058 	.word	0x2009c058
    3ea8:	2009c018 	.word	0x2009c018

Disassembly of section .text.tft_FillScreen:

00003eac <tft_FillScreen>:
    	ili9341_TransferByte(lo);
  	}
  	ili9341_Disable();
}

void tft_FillScreen(u16 color) {
    3eac:	b507      	push	{r0, r1, r2, lr}
  	tft_FillRect(0, 0,  _width, _height, color);
    3eae:	4b07      	ldr	r3, [pc, #28]	; (3ecc <tft_FillScreen+0x20>)
    3eb0:	4a07      	ldr	r2, [pc, #28]	; (3ed0 <tft_FillScreen+0x24>)
    3eb2:	2100      	movs	r1, #0
    3eb4:	f9b3 3000 	ldrsh.w	r3, [r3]
    3eb8:	f9b2 2000 	ldrsh.w	r2, [r2]
    3ebc:	9000      	str	r0, [sp, #0]
    3ebe:	4608      	mov	r0, r1
    3ec0:	f7ff ffa6 	bl	3e10 <tft_FillRect>
}
    3ec4:	b003      	add	sp, #12
    3ec6:	f85d fb04 	ldr.w	pc, [sp], #4
    3eca:	bf00      	nop
    3ecc:	1000003e 	.word	0x1000003e
    3ed0:	10000040 	.word	0x10000040

Disassembly of section .text.tft_Color565:

00003ed4 <tft_Color565>:
}


// Pass 8-bit (each) R,G,B, get back 16-bit packed color
u16 tft_Color565(u8 r, u8 g, u8 b) {
  	return ((r & 0xF8) << 8) | ((g & 0xFC) << 3) | (b >> 3);
    3ed4:	00c9      	lsls	r1, r1, #3
    3ed6:	f401 61fc 	and.w	r1, r1, #2016	; 0x7e0
    3eda:	0200      	lsls	r0, r0, #8
    3edc:	ea41 02d2 	orr.w	r2, r1, r2, lsr #3
    3ee0:	f400 4078 	and.w	r0, r0, #63488	; 0xf800
}
    3ee4:	4310      	orrs	r0, r2
    3ee6:	4770      	bx	lr

Disassembly of section .text.tft_SetRotation:

00003ee8 <tft_SetRotation>:
#define MADCTL_ML  0x10
#define MADCTL_RGB 0x00
#define MADCTL_BGR 0x08
#define MADCTL_MH  0x04

void tft_SetRotation(u8 m) {
    3ee8:	b538      	push	{r3, r4, r5, lr}
    3eea:	4604      	mov	r4, r0
  	tft_WriteCommand(ILI9341_MADCTL);
    3eec:	2036      	movs	r0, #54	; 0x36
    3eee:	f7ff fd87 	bl	3a00 <tft_WriteCommand>
  	switch (m % 4) { // can't be higher than 3
    3ef2:	f004 0003 	and.w	r0, r4, #3
    3ef6:	2802      	cmp	r0, #2
    3ef8:	4d0d      	ldr	r5, [pc, #52]	; (3f30 <tft_SetRotation+0x48>)
    3efa:	4c0e      	ldr	r4, [pc, #56]	; (3f34 <tft_SetRotation+0x4c>)
    3efc:	d005      	beq.n	3f0a <tft_SetRotation+0x22>
    3efe:	2803      	cmp	r0, #3
    3f00:	d005      	beq.n	3f0e <tft_SetRotation+0x26>
    3f02:	2801      	cmp	r0, #1
    3f04:	d10b      	bne.n	3f1e <tft_SetRotation+0x36>
   	case 1:
    	tft_WriteData(MADCTL_MV | MADCTL_BGR);
    3f06:	2028      	movs	r0, #40	; 0x28
    3f08:	e002      	b.n	3f10 <tft_SetRotation+0x28>
     	_width  = gfxHEIGHT;
     	_height = gfxWIDTH;
     	break;
  	case 2:
    	tft_WriteData(MADCTL_MY | MADCTL_BGR);
    3f0a:	2088      	movs	r0, #136	; 0x88
    3f0c:	e008      	b.n	3f20 <tft_SetRotation+0x38>
     	_width  = gfxWIDTH;
     	_height = gfxHEIGHT;
    	break;
   	case 3:
    	tft_WriteData(MADCTL_MX | MADCTL_MY | MADCTL_MV | MADCTL_BGR);
    3f0e:	20e8      	movs	r0, #232	; 0xe8
    3f10:	f7ff fd88 	bl	3a24 <tft_WriteData>
     	_width  = gfxHEIGHT;
    3f14:	f44f 73a0 	mov.w	r3, #320	; 0x140
    3f18:	802b      	strh	r3, [r5, #0]
     	_height = gfxWIDTH;
    3f1a:	23f0      	movs	r3, #240	; 0xf0
    3f1c:	e006      	b.n	3f2c <tft_SetRotation+0x44>
     	break;
     default: // case 0:
     	tft_WriteData(MADCTL_MX | MADCTL_BGR);
    3f1e:	2048      	movs	r0, #72	; 0x48
    3f20:	f7ff fd80 	bl	3a24 <tft_WriteData>
     	_width  = gfxWIDTH;
    3f24:	23f0      	movs	r3, #240	; 0xf0
    3f26:	802b      	strh	r3, [r5, #0]
     	_height = gfxHEIGHT;
    3f28:	f44f 73a0 	mov.w	r3, #320	; 0x140
    3f2c:	8023      	strh	r3, [r4, #0]
    3f2e:	bd38      	pop	{r3, r4, r5, pc}
    3f30:	10000040 	.word	0x10000040
    3f34:	1000003e 	.word	0x1000003e

Disassembly of section .text.tft_Width:

00003f38 <tft_Width>:
  	tft_WriteCommand(i ? ILI9341_INVON : ILI9341_INVOFF);
}

u16 tft_Width(void) {
	return _width;
}
    3f38:	4b01      	ldr	r3, [pc, #4]	; (3f40 <tft_Width+0x8>)
    3f3a:	8818      	ldrh	r0, [r3, #0]
    3f3c:	4770      	bx	lr
    3f3e:	bf00      	nop
    3f40:	10000040 	.word	0x10000040

Disassembly of section .text.tft_Height:

00003f44 <tft_Height>:

u16 tft_Height(void) {
	return _height;
}
    3f44:	4b01      	ldr	r3, [pc, #4]	; (3f4c <tft_Height+0x8>)
    3f46:	8818      	ldrh	r0, [r3, #0]
    3f48:	4770      	bx	lr
    3f4a:	bf00      	nop
    3f4c:	1000003e 	.word	0x1000003e

Disassembly of section .text.gfx_Init:

00003f50 <gfx_Init>:
  	_height   = gfxHEIGHT;
  	rotation  = 0;
  	cursor_y  = 0;
  	cursor_x  = 0;
  	textsize  = 1;
  	textcolor = clWhite;
    3f50:	f64f 70ff 	movw	r0, #65535	; 0xffff
//  	int bytes = tft_Width() * tft_Height() * 2;
//  	if((buffer = (u16*)malloc(bytes))) {
//    		memset(buffer, 0, bytes);
//  	}

  	_width    = gfxWIDTH;
    3f54:	4b0b      	ldr	r3, [pc, #44]	; (3f84 <gfx_Init+0x34>)
    3f56:	22f0      	movs	r2, #240	; 0xf0
    3f58:	601a      	str	r2, [r3, #0]
  	_height   = gfxHEIGHT;
    3f5a:	4b0b      	ldr	r3, [pc, #44]	; (3f88 <gfx_Init+0x38>)
    3f5c:	f44f 72a0 	mov.w	r2, #320	; 0x140
    3f60:	601a      	str	r2, [r3, #0]
  	rotation  = 0;
    3f62:	4a0a      	ldr	r2, [pc, #40]	; (3f8c <gfx_Init+0x3c>)
    3f64:	2300      	movs	r3, #0
    3f66:	6013      	str	r3, [r2, #0]
  	cursor_y  = 0;
    3f68:	4a09      	ldr	r2, [pc, #36]	; (3f90 <gfx_Init+0x40>)
  	cursor_x  = 0;
  	textsize  = 1;
    3f6a:	490a      	ldr	r1, [pc, #40]	; (3f94 <gfx_Init+0x44>)
//  	}

  	_width    = gfxWIDTH;
  	_height   = gfxHEIGHT;
  	rotation  = 0;
  	cursor_y  = 0;
    3f6c:	6013      	str	r3, [r2, #0]
  	cursor_x  = 0;
    3f6e:	4a0a      	ldr	r2, [pc, #40]	; (3f98 <gfx_Init+0x48>)
    3f70:	6013      	str	r3, [r2, #0]
  	textsize  = 1;
    3f72:	2201      	movs	r2, #1
    3f74:	600a      	str	r2, [r1, #0]
  	textcolor = clWhite;
    3f76:	4909      	ldr	r1, [pc, #36]	; (3f9c <gfx_Init+0x4c>)
    3f78:	6008      	str	r0, [r1, #0]
  	//textbgcolor = clWhite;
  	wrap      = pdTRUE;
    3f7a:	4909      	ldr	r1, [pc, #36]	; (3fa0 <gfx_Init+0x50>)
    3f7c:	600a      	str	r2, [r1, #0]
  	_cp437    = pdFALSE;
  	gfxFont   = NULL;
    3f7e:	4a09      	ldr	r2, [pc, #36]	; (3fa4 <gfx_Init+0x54>)
    3f80:	6013      	str	r3, [r2, #0]
    3f82:	4770      	bx	lr
    3f84:	10000860 	.word	0x10000860
    3f88:	10000874 	.word	0x10000874
    3f8c:	10000880 	.word	0x10000880
    3f90:	1000087c 	.word	0x1000087c
    3f94:	1000086c 	.word	0x1000086c
    3f98:	10000878 	.word	0x10000878
    3f9c:	10000864 	.word	0x10000864
    3fa0:	10000868 	.word	0x10000868
    3fa4:	100005f8 	.word	0x100005f8

Disassembly of section .text.gfx_SetRotation:

00003fa8 <gfx_SetRotation>:
//      		for(i=0; i<pixels; i++) buffer[i] = color;
//    	}
//  	}
//}

void gfx_SetRotation(u8 x) {
    3fa8:	f000 0003 	and.w	r0, r0, #3
  	rotation = (x & 3);
    3fac:	4b09      	ldr	r3, [pc, #36]	; (3fd4 <gfx_SetRotation+0x2c>)
  	switch(rotation) {
    3fae:	2801      	cmp	r0, #1
//    	}
//  	}
//}

void gfx_SetRotation(u8 x) {
  	rotation = (x & 3);
    3fb0:	6018      	str	r0, [r3, #0]
    3fb2:	4a09      	ldr	r2, [pc, #36]	; (3fd8 <gfx_SetRotation+0x30>)
    3fb4:	4b09      	ldr	r3, [pc, #36]	; (3fdc <gfx_SetRotation+0x34>)
  	switch(rotation) {
    3fb6:	d006      	beq.n	3fc6 <gfx_SetRotation+0x1e>
    3fb8:	2803      	cmp	r0, #3
    3fba:	d004      	beq.n	3fc6 <gfx_SetRotation+0x1e>
   	case 0:
   	case 2:
    	_width  = gfxWIDTH;
    3fbc:	21f0      	movs	r1, #240	; 0xf0
    3fbe:	6011      	str	r1, [r2, #0]
    	_height = gfxHEIGHT;
    3fc0:	f44f 72a0 	mov.w	r2, #320	; 0x140
    3fc4:	e003      	b.n	3fce <gfx_SetRotation+0x26>
    	break;
   	case 1:
   	case 3:
    	_width  = gfxHEIGHT;
    3fc6:	f44f 71a0 	mov.w	r1, #320	; 0x140
    3fca:	6011      	str	r1, [r2, #0]
    	_height = gfxWIDTH;
    3fcc:	22f0      	movs	r2, #240	; 0xf0
    3fce:	601a      	str	r2, [r3, #0]
    	break;
  	}
	tft_SetRotation(rotation);
    3fd0:	f7ff bf8a 	b.w	3ee8 <tft_SetRotation>
    3fd4:	10000880 	.word	0x10000880
    3fd8:	10000860 	.word	0x10000860
    3fdc:	10000874 	.word	0x10000874

Disassembly of section .text.gfx_DrawLine:

00003fe0 <gfx_DrawLine>:
//	}
//	buffer[x + y * gfxWIDTH] = color;
//}

// Bresenham's algorithm - thx wikpedia
void gfx_DrawLine(int x0, int y0, int x1, int y1, int color) {
    3fe0:	e92d 4ff7 	stmdb	sp!, {r0, r1, r2, r4, r5, r6, r7, r8, r9, sl, fp, lr}
  	int steep = abs(y1 - y0) > abs(x1 - x0);
    3fe4:	ebc1 0803 	rsb	r8, r1, r3
//	}
//	buffer[x + y * gfxWIDTH] = color;
//}

// Bresenham's algorithm - thx wikpedia
void gfx_DrawLine(int x0, int y0, int x1, int y1, int color) {
    3fe8:	461e      	mov	r6, r3
  	int steep = abs(y1 - y0) > abs(x1 - x0);
    3fea:	4643      	mov	r3, r8
    3fec:	ebc0 0902 	rsb	r9, r0, r2
    3ff0:	2b00      	cmp	r3, #0
    3ff2:	bfb8      	it	lt
    3ff4:	425b      	neglt	r3, r3
    3ff6:	f1b9 0f00 	cmp.w	r9, #0
    3ffa:	bfb8      	it	lt
    3ffc:	f1c9 0900 	rsblt	r9, r9, #0
  	if (steep) {
    4000:	454b      	cmp	r3, r9
//	}
//	buffer[x + y * gfxWIDTH] = color;
//}

// Bresenham's algorithm - thx wikpedia
void gfx_DrawLine(int x0, int y0, int x1, int y1, int color) {
    4002:	4604      	mov	r4, r0
    4004:	460d      	mov	r5, r1
    4006:	4617      	mov	r7, r2
  	int steep = abs(y1 - y0) > abs(x1 - x0);
    4008:	9300      	str	r3, [sp, #0]
  	if (steep) {
    400a:	dd03      	ble.n	4014 <gfx_DrawLine+0x34>
    	swap_int16(x0, y0);
    	swap_int16(x1, y1);
    400c:	4637      	mov	r7, r6

// Bresenham's algorithm - thx wikpedia
void gfx_DrawLine(int x0, int y0, int x1, int y1, int color) {
  	int steep = abs(y1 - y0) > abs(x1 - x0);
  	if (steep) {
    	swap_int16(x0, y0);
    400e:	460c      	mov	r4, r1
    	swap_int16(x1, y1);
    4010:	4616      	mov	r6, r2

// Bresenham's algorithm - thx wikpedia
void gfx_DrawLine(int x0, int y0, int x1, int y1, int color) {
  	int steep = abs(y1 - y0) > abs(x1 - x0);
  	if (steep) {
    	swap_int16(x0, y0);
    4012:	4605      	mov	r5, r0
    	swap_int16(x1, y1);
  	}

  	if (x0 > x1) {
    4014:	42bc      	cmp	r4, r7
    4016:	dd05      	ble.n	4024 <gfx_DrawLine+0x44>
    4018:	462b      	mov	r3, r5
    	swap_int16(x0, x1);
    	swap_int16(y0, y1);
    401a:	4635      	mov	r5, r6
    401c:	461e      	mov	r6, r3
  	if (steep) {
    	swap_int16(x0, y0);
    	swap_int16(x1, y1);
  	}

  	if (x0 > x1) {
    401e:	4623      	mov	r3, r4
    4020:	463c      	mov	r4, r7
    4022:	461f      	mov	r7, r3
    	swap_int16(y0, y1);
	}

  	int dx, dy;
  	dx = x1 - x0;
  	dy = abs(y1 - y0);
    4024:	1b73      	subs	r3, r6, r5
    4026:	2b00      	cmp	r3, #0
    4028:	bfb8      	it	lt
    402a:	425b      	neglt	r3, r3
    	swap_int16(x0, x1);
    	swap_int16(y0, y1);
	}

  	int dx, dy;
  	dx = x1 - x0;
    402c:	ebc4 0a07 	rsb	sl, r4, r7
  	dy = abs(y1 - y0);
    4030:	9301      	str	r3, [sp, #4]

  	int err = dx / 2;
    4032:	2302      	movs	r3, #2
    4034:	fb9a f8f3 	sdiv	r8, sl, r3
  	int ystep;

  	if (y0 < y1) ystep = 1; else ystep = -1;
    4038:	42b5      	cmp	r5, r6
    403a:	bfb4      	ite	lt
    403c:	2601      	movlt	r6, #1
    403e:	f04f 36ff 	movge.w	r6, #4294967295
    4042:	f8bd b030 	ldrh.w	fp, [sp, #48]	; 0x30

  	for (; x0<=x1; x0++) {
    4046:	42bc      	cmp	r4, r7
    4048:	dc13      	bgt.n	4072 <gfx_DrawLine+0x92>
    	if (steep) {
    404a:	9b00      	ldr	r3, [sp, #0]
    404c:	b220      	sxth	r0, r4
    404e:	454b      	cmp	r3, r9
    4050:	fa0f fe85 	sxth.w	lr, r5
      		gfx_DrawPixel(y0, x0, color);
    4054:	bfca      	itet	gt
    4056:	4601      	movgt	r1, r0
    	} else {
      		gfx_DrawPixel(x0, y0, color);
    4058:	4671      	movle	r1, lr

  	if (y0 < y1) ystep = 1; else ystep = -1;

  	for (; x0<=x1; x0++) {
    	if (steep) {
      		gfx_DrawPixel(y0, x0, color);
    405a:	4670      	movgt	r0, lr
    405c:	465a      	mov	r2, fp
    	} else {
      		gfx_DrawPixel(x0, y0, color);
    405e:	f7ff fe39 	bl	3cd4 <tft_DrawPixel>
    	}
    	err -= dy;
    	if (err < 0) {
    4062:	9b01      	ldr	r3, [sp, #4]
  	int err = dx / 2;
  	int ystep;

  	if (y0 < y1) ystep = 1; else ystep = -1;

  	for (; x0<=x1; x0++) {
    4064:	3401      	adds	r4, #1
      		gfx_DrawPixel(y0, x0, color);
    	} else {
      		gfx_DrawPixel(x0, y0, color);
    	}
    	err -= dy;
    	if (err < 0) {
    4066:	ebb8 0803 	subs.w	r8, r8, r3
      		y0 += ystep;
    406a:	bf44      	itt	mi
    406c:	19ad      	addmi	r5, r5, r6
      		err += dx;
    406e:	44d0      	addmi	r8, sl
    4070:	e7e9      	b.n	4046 <gfx_DrawLine+0x66>
    	}
  	}
}
    4072:	b003      	add	sp, #12
    4074:	e8bd 8ff0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}

Disassembly of section .text.gfx_FillRect:

00004078 <gfx_FillRect>:
  	//gfx_DrawLine(x, y, x+w-1, y, color); // se usar buffer

  	tft_DrawFastHLine(x, y, w, color);
}

void gfx_FillRect(int x, int y, int w, int h, uint color) {
    4078:	e92d 41f0 	stmdb	sp!, {r4, r5, r6, r7, r8, lr}
    407c:	460e      	mov	r6, r1
  	// Update in subclasses if desired!
  	int i; for (i=x; i<x+w; i++) gfx_DrawFastVLine(i, y, h, color);
    407e:	4604      	mov	r4, r0
}

void gfx_DrawFastVLine(s16 x, s16 y, s16 h, uint color) {
  	// Update in subclasses if desired!
  	//gfx_DrawLine(x, y, x, y+h-1, color); // se usar buffer
  	tft_DrawFastVLine(x, y, h, color);
    4080:	f8bd 7018 	ldrh.w	r7, [sp, #24]
  	tft_DrawFastHLine(x, y, w, color);
}

void gfx_FillRect(int x, int y, int w, int h, uint color) {
  	// Update in subclasses if desired!
  	int i; for (i=x; i<x+w; i++) gfx_DrawFastVLine(i, y, h, color);
    4084:	1885      	adds	r5, r0, r2
}

void gfx_DrawFastVLine(s16 x, s16 y, s16 h, uint color) {
  	// Update in subclasses if desired!
  	//gfx_DrawLine(x, y, x, y+h-1, color); // se usar buffer
  	tft_DrawFastVLine(x, y, h, color);
    4086:	fa0f f883 	sxth.w	r8, r3
  	tft_DrawFastHLine(x, y, w, color);
}

void gfx_FillRect(int x, int y, int w, int h, uint color) {
  	// Update in subclasses if desired!
  	int i; for (i=x; i<x+w; i++) gfx_DrawFastVLine(i, y, h, color);
    408a:	42ac      	cmp	r4, r5
    408c:	da07      	bge.n	409e <gfx_FillRect+0x26>
}

void gfx_DrawFastVLine(s16 x, s16 y, s16 h, uint color) {
  	// Update in subclasses if desired!
  	//gfx_DrawLine(x, y, x, y+h-1, color); // se usar buffer
  	tft_DrawFastVLine(x, y, h, color);
    408e:	b220      	sxth	r0, r4
    4090:	463b      	mov	r3, r7
    4092:	4642      	mov	r2, r8
    4094:	b231      	sxth	r1, r6
    4096:	f7ff fe4b 	bl	3d30 <tft_DrawFastVLine>
  	tft_DrawFastHLine(x, y, w, color);
}

void gfx_FillRect(int x, int y, int w, int h, uint color) {
  	// Update in subclasses if desired!
  	int i; for (i=x; i<x+w; i++) gfx_DrawFastVLine(i, y, h, color);
    409a:	3401      	adds	r4, #1
    409c:	e7f5      	b.n	408a <gfx_FillRect+0x12>
  	// tft_FillRect(x, y, w, h, color); // se usar buffer
}
    409e:	e8bd 81f0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, pc}

Disassembly of section .text.gfx_FillScreen:

000040a4 <gfx_FillScreen>:

void gfx_FillScreen(uint color) {
    40a4:	b507      	push	{r0, r1, r2, lr}
  	 gfx_FillRect(0, 0, _width, _height, color);
    40a6:	4b06      	ldr	r3, [pc, #24]	; (40c0 <gfx_FillScreen+0x1c>)
    40a8:	4a06      	ldr	r2, [pc, #24]	; (40c4 <gfx_FillScreen+0x20>)
    40aa:	9000      	str	r0, [sp, #0]
    40ac:	2100      	movs	r1, #0
    40ae:	681b      	ldr	r3, [r3, #0]
    40b0:	6812      	ldr	r2, [r2, #0]
    40b2:	4608      	mov	r0, r1
    40b4:	f7ff ffe0 	bl	4078 <gfx_FillRect>
  	 // tft_FillRect(0, 0, _width,_heighth, color); // se usar buffer
	//  if(buffer) {
	//    uint16_t bytes = ((WIDTH + 7) / 8) * HEIGHT;
	//    memset(buffer, color ? 0xFF : 0x00, bytes);
	//  }
}
    40b8:	b003      	add	sp, #12
    40ba:	f85d fb04 	ldr.w	pc, [sp], #4
    40be:	bf00      	nop
    40c0:	10000874 	.word	0x10000874
    40c4:	10000860 	.word	0x10000860

Disassembly of section .text.gfx_DrawRect:

000040c8 <gfx_DrawRect>:

// Draw a rectangle
void gfx_DrawRect(int x, int y, int w, int h, uint color) {
    40c8:	e92d 4ff1 	stmdb	sp!, {r0, r4, r5, r6, r7, r8, r9, sl, fp, lr}
    40cc:	461c      	mov	r4, r3
    40ce:	4689      	mov	r9, r1

void gfx_DrawFastHLine(s16 x, s16 y, s16 w, uint color) {
  	// Update in subclasses if desired!
  	//gfx_DrawLine(x, y, x+w-1, y, color); // se usar buffer

  	tft_DrawFastHLine(x, y, w, color);
    40d0:	f8bd 6028 	ldrh.w	r6, [sp, #40]	; 0x28
	//  }
}

// Draw a rectangle
void gfx_DrawRect(int x, int y, int w, int h, uint color) {
  	gfx_DrawFastHLine(x, y, w, color);
    40d4:	fa0f fa80 	sxth.w	sl, r0
    40d8:	fa0f f881 	sxth.w	r8, r1
    40dc:	fa0f fb82 	sxth.w	fp, r2
	//    memset(buffer, color ? 0xFF : 0x00, bytes);
	//  }
}

// Draw a rectangle
void gfx_DrawRect(int x, int y, int w, int h, uint color) {
    40e0:	4605      	mov	r5, r0
    40e2:	4617      	mov	r7, r2

void gfx_DrawFastHLine(s16 x, s16 y, s16 w, uint color) {
  	// Update in subclasses if desired!
  	//gfx_DrawLine(x, y, x+w-1, y, color); // se usar buffer

  	tft_DrawFastHLine(x, y, w, color);
    40e4:	4633      	mov	r3, r6
    40e6:	465a      	mov	r2, fp
    40e8:	4641      	mov	r1, r8
    40ea:	4650      	mov	r0, sl
    40ec:	f7ff fe58 	bl	3da0 <tft_DrawFastHLine>
    40f0:	1e61      	subs	r1, r4, #1
    40f2:	4449      	add	r1, r9
    40f4:	4633      	mov	r3, r6
    40f6:	465a      	mov	r2, fp
    40f8:	4650      	mov	r0, sl

// Draw a rectangle
void gfx_DrawRect(int x, int y, int w, int h, uint color) {
  	gfx_DrawFastHLine(x, y, w, color);
  	gfx_DrawFastHLine(x, y+h-1, w, color);
  	gfx_DrawFastVLine(x, y, h, color);
    40fa:	b224      	sxth	r4, r4

void gfx_DrawFastHLine(s16 x, s16 y, s16 w, uint color) {
  	// Update in subclasses if desired!
  	//gfx_DrawLine(x, y, x+w-1, y, color); // se usar buffer

  	tft_DrawFastHLine(x, y, w, color);
    40fc:	b209      	sxth	r1, r1
    40fe:	f7ff fe4f 	bl	3da0 <tft_DrawFastHLine>
}

void gfx_DrawFastVLine(s16 x, s16 y, s16 h, uint color) {
  	// Update in subclasses if desired!
  	//gfx_DrawLine(x, y, x, y+h-1, color); // se usar buffer
  	tft_DrawFastVLine(x, y, h, color);
    4102:	4633      	mov	r3, r6
    4104:	4622      	mov	r2, r4
    4106:	4641      	mov	r1, r8
    4108:	4650      	mov	r0, sl
    410a:	f7ff fe11 	bl	3d30 <tft_DrawFastVLine>
    410e:	4633      	mov	r3, r6
    4110:	4622      	mov	r2, r4
    4112:	4641      	mov	r1, r8
    4114:	1e78      	subs	r0, r7, #1
    4116:	4428      	add	r0, r5
    4118:	b200      	sxth	r0, r0
void gfx_DrawRect(int x, int y, int w, int h, uint color) {
  	gfx_DrawFastHLine(x, y, w, color);
  	gfx_DrawFastHLine(x, y+h-1, w, color);
  	gfx_DrawFastVLine(x, y, h, color);
  	gfx_DrawFastVLine(x+w-1, y, h, color);
}
    411a:	b001      	add	sp, #4
    411c:	e8bd 4ff0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
}

void gfx_DrawFastVLine(s16 x, s16 y, s16 h, uint color) {
  	// Update in subclasses if desired!
  	//gfx_DrawLine(x, y, x, y+h-1, color); // se usar buffer
  	tft_DrawFastVLine(x, y, h, color);
    4120:	f7ff be06 	b.w	3d30 <tft_DrawFastVLine>

Disassembly of section .text.gfx_DrawTriangle:

00004124 <gfx_DrawTriangle>:
  	gfx_DrawFastVLine(x, y, h, color);
  	gfx_DrawFastVLine(x+w-1, y, h, color);
}

// Draw a triangle
void gfx_DrawTriangle(int x0, int y0, int x1, int y1, int x2, int y2, uint color) {
    4124:	e92d 47f3 	stmdb	sp!, {r0, r1, r4, r5, r6, r7, r8, r9, sl, lr}
    4128:	4691      	mov	r9, r2
    412a:	469a      	mov	sl, r3
    412c:	4607      	mov	r7, r0
    412e:	4688      	mov	r8, r1
    4130:	9c0c      	ldr	r4, [sp, #48]	; 0x30
    4132:	9d0a      	ldr	r5, [sp, #40]	; 0x28
    4134:	9e0b      	ldr	r6, [sp, #44]	; 0x2c
  	gfx_DrawLine(x0, y0, x1, y1, color);
    4136:	9400      	str	r4, [sp, #0]
    4138:	f7ff ff52 	bl	3fe0 <gfx_DrawLine>
  	gfx_DrawLine(x1, y1, x2, y2, color);
    413c:	4633      	mov	r3, r6
    413e:	462a      	mov	r2, r5
    4140:	4651      	mov	r1, sl
    4142:	4648      	mov	r0, r9
    4144:	9400      	str	r4, [sp, #0]
    4146:	f7ff ff4b 	bl	3fe0 <gfx_DrawLine>
  	gfx_DrawLine(x2, y2, x0, y0, color);
    414a:	4643      	mov	r3, r8
    414c:	463a      	mov	r2, r7
    414e:	4631      	mov	r1, r6
    4150:	4628      	mov	r0, r5
    4152:	940a      	str	r4, [sp, #40]	; 0x28
}
    4154:	b002      	add	sp, #8
    4156:	e8bd 47f0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, r9, sl, lr}

// Draw a triangle
void gfx_DrawTriangle(int x0, int y0, int x1, int y1, int x2, int y2, uint color) {
  	gfx_DrawLine(x0, y0, x1, y1, color);
  	gfx_DrawLine(x1, y1, x2, y2, color);
  	gfx_DrawLine(x2, y2, x0, y0, color);
    415a:	f7ff bf41 	b.w	3fe0 <gfx_DrawLine>

Disassembly of section .text.gfx_FillTriangle:

0000415e <gfx_FillTriangle>:
}

void gfx_FillTriangle(int x0, int y0, int x1, int y1, int x2, int y2, uint color) {
    415e:	e92d 4ff0 	stmdb	sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
    4162:	460d      	mov	r5, r1
    4164:	461e      	mov	r6, r3
    4166:	b08b      	sub	sp, #44	; 0x2c
    4168:	9916      	ldr	r1, [sp, #88]	; 0x58
  	int a, b, y, last;

  	// Sort coordinates by Y order (y2 >= y1 >= y0)
  	if (y0 > y1) {
    416a:	42b5      	cmp	r5, r6
  	gfx_DrawLine(x0, y0, x1, y1, color);
  	gfx_DrawLine(x1, y1, x2, y2, color);
  	gfx_DrawLine(x2, y2, x0, y0, color);
}

void gfx_FillTriangle(int x0, int y0, int x1, int y1, int x2, int y2, uint color) {
    416c:	4617      	mov	r7, r2
    416e:	4604      	mov	r4, r0
    4170:	9a14      	ldr	r2, [sp, #80]	; 0x50
    4172:	9b15      	ldr	r3, [sp, #84]	; 0x54
    4174:	9102      	str	r1, [sp, #8]
  	int a, b, y, last;

  	// Sort coordinates by Y order (y2 >= y1 >= y0)
  	if (y0 > y1) {
    4176:	dd05      	ble.n	4184 <gfx_FillTriangle+0x26>
    	swap_int16(y0, y1); swap_int16(x0, x1);
  	}
  	if (y1 > y2) {
    4178:	429d      	cmp	r5, r3
    417a:	dd0d      	ble.n	4198 <gfx_FillTriangle+0x3a>
    417c:	46a9      	mov	r9, r5
void gfx_FillTriangle(int x0, int y0, int x1, int y1, int x2, int y2, uint color) {
  	int a, b, y, last;

  	// Sort coordinates by Y order (y2 >= y1 >= y0)
  	if (y0 > y1) {
    	swap_int16(y0, y1); swap_int16(x0, x1);
    417e:	463c      	mov	r4, r7
    4180:	4635      	mov	r5, r6
    4182:	e004      	b.n	418e <gfx_FillTriangle+0x30>
  	}
  	if (y1 > y2) {
    4184:	429e      	cmp	r6, r3
    4186:	f340 8095 	ble.w	42b4 <gfx_FillTriangle+0x156>
    418a:	46b1      	mov	r9, r6
    418c:	4638      	mov	r0, r7
    	swap_int16(y2, y1); swap_int16(x2, x1);
  	}
  	if (y0 > y1) {
    418e:	42ab      	cmp	r3, r5
    4190:	db0b      	blt.n	41aa <gfx_FillTriangle+0x4c>
    4192:	461e      	mov	r6, r3
    4194:	4617      	mov	r7, r2
    4196:	e00c      	b.n	41b2 <gfx_FillTriangle+0x54>
    4198:	4699      	mov	r9, r3
    419a:	4633      	mov	r3, r6
    419c:	462e      	mov	r6, r5
    419e:	461d      	mov	r5, r3
    41a0:	463b      	mov	r3, r7
    41a2:	4610      	mov	r0, r2
void gfx_FillTriangle(int x0, int y0, int x1, int y1, int x2, int y2, uint color) {
  	int a, b, y, last;

  	// Sort coordinates by Y order (y2 >= y1 >= y0)
  	if (y0 > y1) {
    	swap_int16(y0, y1); swap_int16(x0, x1);
    41a4:	4627      	mov	r7, r4
    41a6:	461c      	mov	r4, r3
    41a8:	e003      	b.n	41b2 <gfx_FillTriangle+0x54>
    41aa:	462e      	mov	r6, r5
    41ac:	4627      	mov	r7, r4
    41ae:	461d      	mov	r5, r3
    41b0:	4614      	mov	r4, r2
  	}
  	if (y0 > y1) {
    	swap_int16(y0, y1); swap_int16(x0, x1);
  	}

  	if(y0 == y2) { // Handle awkward all-on-same-line case as its own thing
    41b2:	454d      	cmp	r5, r9
    41b4:	d119      	bne.n	41ea <gfx_FillTriangle+0x8c>
    	a = b = x0;
    	if(x1 < a)      a = x1;
    41b6:	42bc      	cmp	r4, r7
    41b8:	dc05      	bgt.n	41c6 <gfx_FillTriangle+0x68>
    41ba:	42a7      	cmp	r7, r4
    41bc:	463b      	mov	r3, r7
    41be:	bfb8      	it	lt
    41c0:	4623      	movlt	r3, r4
    41c2:	4627      	mov	r7, r4
    41c4:	461c      	mov	r4, r3
    	else if(x1 > b) b = x1;
    	if(x2 < a)      a = x2;
    41c6:	4287      	cmp	r7, r0
    41c8:	dc03      	bgt.n	41d2 <gfx_FillTriangle+0x74>
    41ca:	4284      	cmp	r4, r0
    41cc:	bfb8      	it	lt
    41ce:	4604      	movlt	r4, r0
    41d0:	4638      	mov	r0, r7

void gfx_DrawFastHLine(s16 x, s16 y, s16 w, uint color) {
  	// Update in subclasses if desired!
  	//gfx_DrawLine(x, y, x+w-1, y, color); // se usar buffer

  	tft_DrawFastHLine(x, y, w, color);
    41d2:	1c62      	adds	r2, r4, #1
    41d4:	1a12      	subs	r2, r2, r0
    41d6:	f8bd 3008 	ldrh.w	r3, [sp, #8]
    41da:	b212      	sxth	r2, r2
    41dc:	b229      	sxth	r1, r5
    41de:	b200      	sxth	r0, r0
    	sb += dx02;

    	if(a > b) swap_int16(a,b);
    	gfx_DrawFastHLine(a, y, b-a+1, color);
  	}
}
    41e0:	b00b      	add	sp, #44	; 0x2c
    41e2:	e8bd 4ff0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}

void gfx_DrawFastHLine(s16 x, s16 y, s16 w, uint color) {
  	// Update in subclasses if desired!
  	//gfx_DrawLine(x, y, x+w-1, y, color); // se usar buffer

  	tft_DrawFastHLine(x, y, w, color);
    41e6:	f7ff bddb 	b.w	3da0 <tft_DrawFastHLine>
    	dy02 = y2 - y0,
    	dx12 = x2 - x1,
    	dy12 = y2 - y1;
  	s32
    	sa   = 0,
    	sb   = 0;
    41ea:	f04f 0b00 	mov.w	fp, #0
  	// in the second loop...which also avoids a /0 error here if y0=y1
  	// (flat-topped triangle).
  	if(y1 == y2) last = y1;   // Include y1 scanline
  	else         last = y1-1; // Skip it

  	for(y=y0; y<=last; y++) {
    41ee:	46a8      	mov	r8, r5
    	dx02 = x2 - x0,
    	dy02 = y2 - y0,
    	dx12 = x2 - x1,
    	dy12 = y2 - y1;
  	s32
    	sa   = 0,
    41f0:	46da      	mov	sl, fp
    	gfx_DrawFastHLine(a, y0, b-a+1, color);
    	return;
  	}

  	int
    	dx01 = x1 - x0,
    41f2:	1b3b      	subs	r3, r7, r4
    41f4:	9306      	str	r3, [sp, #24]
    	dy01 = y1 - y0,
    41f6:	1b73      	subs	r3, r6, r5
    41f8:	9307      	str	r3, [sp, #28]
    	dx02 = x2 - x0,
    41fa:	1b03      	subs	r3, r0, r4
    41fc:	9301      	str	r3, [sp, #4]
    	dy02 = y2 - y0,
    41fe:	ebc5 0309 	rsb	r3, r5, r9
    4202:	9304      	str	r3, [sp, #16]
    	dx12 = x2 - x1,
    4204:	1bc3      	subs	r3, r0, r7
  	// 0-1 and 0-2.  If y1=y2 (flat-bottomed triangle), the scanline y1
  	// is included here (and second loop will be skipped, avoiding a /0
  	// error there), otherwise scanline y1 is skipped here and handled
  	// in the second loop...which also avoids a /0 error here if y0=y1
  	// (flat-topped triangle).
  	if(y1 == y2) last = y1;   // Include y1 scanline
    4206:	454e      	cmp	r6, r9
  	int
    	dx01 = x1 - x0,
    	dy01 = y1 - y0,
    	dx02 = x2 - x0,
    	dy02 = y2 - y0,
    	dx12 = x2 - x1,
    4208:	9305      	str	r3, [sp, #20]
    	dy12 = y2 - y1;
    420a:	ebc6 0309 	rsb	r3, r6, r9
    420e:	9308      	str	r3, [sp, #32]
  	// is included here (and second loop will be skipped, avoiding a /0
  	// error there), otherwise scanline y1 is skipped here and handled
  	// in the second loop...which also avoids a /0 error here if y0=y1
  	// (flat-topped triangle).
  	if(y1 == y2) last = y1;   // Include y1 scanline
  	else         last = y1-1; // Skip it
    4210:	bf1c      	itt	ne
    4212:	f106 33ff 	addne.w	r3, r6, #4294967295
    4216:	9303      	strne	r3, [sp, #12]

void gfx_DrawFastHLine(s16 x, s16 y, s16 w, uint color) {
  	// Update in subclasses if desired!
  	//gfx_DrawLine(x, y, x+w-1, y, color); // se usar buffer

  	tft_DrawFastHLine(x, y, w, color);
    4218:	f8bd 3008 	ldrh.w	r3, [sp, #8]
    421c:	bf08      	it	eq
    421e:	9603      	streq	r6, [sp, #12]
    4220:	9309      	str	r3, [sp, #36]	; 0x24
  	// in the second loop...which also avoids a /0 error here if y0=y1
  	// (flat-topped triangle).
  	if(y1 == y2) last = y1;   // Include y1 scanline
  	else         last = y1-1; // Skip it

  	for(y=y0; y<=last; y++) {
    4222:	9b03      	ldr	r3, [sp, #12]
    4224:	4598      	cmp	r8, r3
    4226:	dc1c      	bgt.n	4262 <gfx_FillTriangle+0x104>
    	a   = x0 + sa / dy01;
    4228:	9b07      	ldr	r3, [sp, #28]

void gfx_DrawFastHLine(s16 x, s16 y, s16 w, uint color) {
  	// Update in subclasses if desired!
  	//gfx_DrawLine(x, y, x+w-1, y, color); // se usar buffer

  	tft_DrawFastHLine(x, y, w, color);
    422a:	fa0f f188 	sxth.w	r1, r8
  	// (flat-topped triangle).
  	if(y1 == y2) last = y1;   // Include y1 scanline
  	else         last = y1-1; // Skip it

  	for(y=y0; y<=last; y++) {
    	a   = x0 + sa / dy01;
    422e:	fb9a f0f3 	sdiv	r0, sl, r3
    	b   = x0 + sb / dy02;
    4232:	9b04      	ldr	r3, [sp, #16]
  	// (flat-topped triangle).
  	if(y1 == y2) last = y1;   // Include y1 scanline
  	else         last = y1-1; // Skip it

  	for(y=y0; y<=last; y++) {
    	a   = x0 + sa / dy01;
    4234:	4420      	add	r0, r4
    	b   = x0 + sb / dy02;
    4236:	fb9b f2f3 	sdiv	r2, fp, r3
    	sa += dx01;
    423a:	9b06      	ldr	r3, [sp, #24]
  	if(y1 == y2) last = y1;   // Include y1 scanline
  	else         last = y1-1; // Skip it

  	for(y=y0; y<=last; y++) {
    	a   = x0 + sa / dy01;
    	b   = x0 + sb / dy02;
    423c:	4422      	add	r2, r4
    	sa += dx01;
    423e:	449a      	add	sl, r3
    	sb += dx02;
    4240:	9b01      	ldr	r3, [sp, #4]
    	if(a > b) swap_int16(a,b);
    4242:	4290      	cmp	r0, r2

  	for(y=y0; y<=last; y++) {
    	a   = x0 + sa / dy01;
    	b   = x0 + sb / dy02;
    	sa += dx01;
    	sb += dx02;
    4244:	449b      	add	fp, r3
    	if(a > b) swap_int16(a,b);
    4246:	bfc2      	ittt	gt
    4248:	4603      	movgt	r3, r0
    424a:	4610      	movgt	r0, r2
    424c:	461a      	movgt	r2, r3

void gfx_DrawFastHLine(s16 x, s16 y, s16 w, uint color) {
  	// Update in subclasses if desired!
  	//gfx_DrawLine(x, y, x+w-1, y, color); // se usar buffer

  	tft_DrawFastHLine(x, y, w, color);
    424e:	3201      	adds	r2, #1
    4250:	1a12      	subs	r2, r2, r0
    4252:	9b09      	ldr	r3, [sp, #36]	; 0x24
    4254:	b212      	sxth	r2, r2
    4256:	b200      	sxth	r0, r0
    4258:	f7ff fda2 	bl	3da0 <tft_DrawFastHLine>
  	// in the second loop...which also avoids a /0 error here if y0=y1
  	// (flat-topped triangle).
  	if(y1 == y2) last = y1;   // Include y1 scanline
  	else         last = y1-1; // Skip it

  	for(y=y0; y<=last; y++) {
    425c:	f108 0801 	add.w	r8, r8, #1
    4260:	e7df      	b.n	4222 <gfx_FillTriangle+0xc4>
    	gfx_DrawFastHLine(a, y, b-a+1, color);
  	}

  	// For lower part of triangle, find scanline crossings for segments
  	// 0-2 and 1-2.  This loop is skipped if y1=y2.
  	sa = dx12 * (y - y1);
    4262:	9b05      	ldr	r3, [sp, #20]
    4264:	ebc6 0608 	rsb	r6, r6, r8
    4268:	435e      	muls	r6, r3
  	sb = dx02 * (y - y0);
    426a:	9b01      	ldr	r3, [sp, #4]
    426c:	ebc5 0508 	rsb	r5, r5, r8
    4270:	435d      	muls	r5, r3

void gfx_DrawFastHLine(s16 x, s16 y, s16 w, uint color) {
  	// Update in subclasses if desired!
  	//gfx_DrawLine(x, y, x+w-1, y, color); // se usar buffer

  	tft_DrawFastHLine(x, y, w, color);
    4272:	f8bd a008 	ldrh.w	sl, [sp, #8]

  	// For lower part of triangle, find scanline crossings for segments
  	// 0-2 and 1-2.  This loop is skipped if y1=y2.
  	sa = dx12 * (y - y1);
  	sb = dx02 * (y - y0);
  	for(; y<=y2; y++) {
    4276:	45c8      	cmp	r8, r9
    4278:	dc1f      	bgt.n	42ba <gfx_FillTriangle+0x15c>
    	a   = x1 + sa / dy12;
    427a:	9b08      	ldr	r3, [sp, #32]

void gfx_DrawFastHLine(s16 x, s16 y, s16 w, uint color) {
  	// Update in subclasses if desired!
  	//gfx_DrawLine(x, y, x+w-1, y, color); // se usar buffer

  	tft_DrawFastHLine(x, y, w, color);
    427c:	fa0f f188 	sxth.w	r1, r8
  	// For lower part of triangle, find scanline crossings for segments
  	// 0-2 and 1-2.  This loop is skipped if y1=y2.
  	sa = dx12 * (y - y1);
  	sb = dx02 * (y - y0);
  	for(; y<=y2; y++) {
    	a   = x1 + sa / dy12;
    4280:	fb96 f0f3 	sdiv	r0, r6, r3
    	b   = x0 + sb / dy02;
    4284:	9b04      	ldr	r3, [sp, #16]
  	// For lower part of triangle, find scanline crossings for segments
  	// 0-2 and 1-2.  This loop is skipped if y1=y2.
  	sa = dx12 * (y - y1);
  	sb = dx02 * (y - y0);
  	for(; y<=y2; y++) {
    	a   = x1 + sa / dy12;
    4286:	4438      	add	r0, r7
    	b   = x0 + sb / dy02;
    4288:	fb95 f2f3 	sdiv	r2, r5, r3
    	sa += dx12;
    428c:	9b05      	ldr	r3, [sp, #20]
  	// 0-2 and 1-2.  This loop is skipped if y1=y2.
  	sa = dx12 * (y - y1);
  	sb = dx02 * (y - y0);
  	for(; y<=y2; y++) {
    	a   = x1 + sa / dy12;
    	b   = x0 + sb / dy02;
    428e:	4422      	add	r2, r4
    	sa += dx12;
    4290:	441e      	add	r6, r3
    	sb += dx02;
    4292:	9b01      	ldr	r3, [sp, #4]

    	if(a > b) swap_int16(a,b);
    4294:	4290      	cmp	r0, r2
  	sb = dx02 * (y - y0);
  	for(; y<=y2; y++) {
    	a   = x1 + sa / dy12;
    	b   = x0 + sb / dy02;
    	sa += dx12;
    	sb += dx02;
    4296:	441d      	add	r5, r3

    	if(a > b) swap_int16(a,b);
    4298:	bfc2      	ittt	gt
    429a:	4603      	movgt	r3, r0
    429c:	4610      	movgt	r0, r2
    429e:	461a      	movgt	r2, r3

void gfx_DrawFastHLine(s16 x, s16 y, s16 w, uint color) {
  	// Update in subclasses if desired!
  	//gfx_DrawLine(x, y, x+w-1, y, color); // se usar buffer

  	tft_DrawFastHLine(x, y, w, color);
    42a0:	3201      	adds	r2, #1
    42a2:	1a12      	subs	r2, r2, r0
    42a4:	4653      	mov	r3, sl
    42a6:	b212      	sxth	r2, r2
    42a8:	b200      	sxth	r0, r0
    42aa:	f7ff fd79 	bl	3da0 <tft_DrawFastHLine>

  	// For lower part of triangle, find scanline crossings for segments
  	// 0-2 and 1-2.  This loop is skipped if y1=y2.
  	sa = dx12 * (y - y1);
  	sb = dx02 * (y - y0);
  	for(; y<=y2; y++) {
    42ae:	f108 0801 	add.w	r8, r8, #1
    42b2:	e7e0      	b.n	4276 <gfx_FillTriangle+0x118>

  	// Sort coordinates by Y order (y2 >= y1 >= y0)
  	if (y0 > y1) {
    	swap_int16(y0, y1); swap_int16(x0, x1);
  	}
  	if (y1 > y2) {
    42b4:	4699      	mov	r9, r3
    42b6:	4610      	mov	r0, r2
    42b8:	e77b      	b.n	41b2 <gfx_FillTriangle+0x54>
    	sb += dx02;

    	if(a > b) swap_int16(a,b);
    	gfx_DrawFastHLine(a, y, b-a+1, color);
  	}
}
    42ba:	b00b      	add	sp, #44	; 0x2c
    42bc:	e8bd 8ff0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}

Disassembly of section .text.gfx_DrawCircle:

000042c0 <gfx_DrawCircle>:

// Draw a circle outline
void gfx_DrawCircle(int x0, int y0, int r, uint color) {
    42c0:	e92d 4ff0 	stmdb	sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
    42c4:	4616      	mov	r6, r2
    42c6:	4605      	mov	r5, r0
    42c8:	468a      	mov	sl, r1
  	int f = 1 - r;
    42ca:	f1c2 0701 	rsb	r7, r2, #1
 	int ddF_x = 1;
  	int ddF_y = -2 * r;
    42ce:	f06f 0201 	mvn.w	r2, #1
    42d2:	4372      	muls	r2, r6
  	int x = 0;
  	int y = r;

  	gfx_DrawPixel(x0  , y0+r, color);
    42d4:	fa1f f986 	uxth.w	r9, r6
    42d8:	fa1f f881 	uxth.w	r8, r1
    42dc:	b29c      	uxth	r4, r3
    	gfx_DrawFastHLine(a, y, b-a+1, color);
  	}
}

// Draw a circle outline
void gfx_DrawCircle(int x0, int y0, int r, uint color) {
    42de:	b085      	sub	sp, #20
 	int ddF_x = 1;
  	int ddF_y = -2 * r;
  	int x = 0;
  	int y = r;

  	gfx_DrawPixel(x0  , y0+r, color);
    42e0:	fa0f fb80 	sxth.w	fp, r0
    42e4:	eb08 0109 	add.w	r1, r8, r9

// Draw a circle outline
void gfx_DrawCircle(int x0, int y0, int r, uint color) {
  	int f = 1 - r;
 	int ddF_x = 1;
  	int ddF_y = -2 * r;
    42e8:	9202      	str	r2, [sp, #8]
  	int x = 0;
  	int y = r;

  	gfx_DrawPixel(x0  , y0+r, color);
    42ea:	b209      	sxth	r1, r1
    42ec:	4622      	mov	r2, r4
    42ee:	4658      	mov	r0, fp
    42f0:	f7ff fcf0 	bl	3cd4 <tft_DrawPixel>
  	gfx_DrawPixel(x0  , y0-r, color);
    42f4:	ebc9 0108 	rsb	r1, r9, r8
    42f8:	4622      	mov	r2, r4
    42fa:	b209      	sxth	r1, r1
    42fc:	4658      	mov	r0, fp
  	gfx_DrawPixel(x0+r, y0  , color);
    42fe:	b2ad      	uxth	r5, r5
  	int ddF_y = -2 * r;
  	int x = 0;
  	int y = r;

  	gfx_DrawPixel(x0  , y0+r, color);
  	gfx_DrawPixel(x0  , y0-r, color);
    4300:	f7ff fce8 	bl	3cd4 <tft_DrawPixel>
  	gfx_DrawPixel(x0+r, y0  , color);
    4304:	fa0f fa8a 	sxth.w	sl, sl
    4308:	eb09 0005 	add.w	r0, r9, r5
    430c:	4622      	mov	r2, r4
    430e:	4651      	mov	r1, sl
    4310:	b200      	sxth	r0, r0
    4312:	f7ff fcdf 	bl	3cd4 <tft_DrawPixel>
  	gfx_DrawPixel(x0-r, y0  , color);
    4316:	ebc9 0005 	rsb	r0, r9, r5
    431a:	4622      	mov	r2, r4
    431c:	4651      	mov	r1, sl
    431e:	b200      	sxth	r0, r0
    4320:	f7ff fcd8 	bl	3cd4 <tft_DrawPixel>
// Draw a circle outline
void gfx_DrawCircle(int x0, int y0, int r, uint color) {
  	int f = 1 - r;
 	int ddF_x = 1;
  	int ddF_y = -2 * r;
  	int x = 0;
    4324:	f04f 0900 	mov.w	r9, #0
  	gfx_DrawPixel(x0  , y0+r, color);
  	gfx_DrawPixel(x0  , y0-r, color);
  	gfx_DrawPixel(x0+r, y0  , color);
  	gfx_DrawPixel(x0-r, y0  , color);

  	while (x<y) {
    4328:	45b1      	cmp	r9, r6
    432a:	da5f      	bge.n	43ec <gfx_DrawCircle+0x12c>
  		if (f >= 0) {
    432c:	2f00      	cmp	r7, #0
    432e:	db04      	blt.n	433a <gfx_DrawCircle+0x7a>
      		y--;
      		ddF_y += 2;
    4330:	9b02      	ldr	r3, [sp, #8]
  	gfx_DrawPixel(x0+r, y0  , color);
  	gfx_DrawPixel(x0-r, y0  , color);

  	while (x<y) {
  		if (f >= 0) {
      		y--;
    4332:	3e01      	subs	r6, #1
      		ddF_y += 2;
    4334:	3302      	adds	r3, #2
    4336:	9302      	str	r3, [sp, #8]
      		f += ddF_y;
    4338:	441f      	add	r7, r3
    	}
    	x++;
    433a:	f109 0901 	add.w	r9, r9, #1
    	ddF_x += 2;
    	f += ddF_x;

    	gfx_DrawPixel(x0 + x, y0 + y, color);
    433e:	b2b2      	uxth	r2, r6
    4340:	fa1f f389 	uxth.w	r3, r9
    4344:	9301      	str	r3, [sp, #4]
    4346:	eb08 0b02 	add.w	fp, r8, r2
    434a:	18eb      	adds	r3, r5, r3
    434c:	b21b      	sxth	r3, r3
    434e:	fa0f fb8b 	sxth.w	fp, fp
    4352:	9200      	str	r2, [sp, #0]
    4354:	4659      	mov	r1, fp
    4356:	4622      	mov	r2, r4
    4358:	4618      	mov	r0, r3
    435a:	9303      	str	r3, [sp, #12]
    435c:	f7ff fcba 	bl	3cd4 <tft_DrawPixel>
    4360:	9b01      	ldr	r3, [sp, #4]
    	gfx_DrawPixel(x0 - x, y0 + y, color);
    4362:	4622      	mov	r2, r4
    4364:	ebc3 0a05 	rsb	sl, r3, r5
    4368:	fa0f fa8a 	sxth.w	sl, sl
    436c:	4659      	mov	r1, fp
    436e:	4650      	mov	r0, sl
    4370:	f7ff fcb0 	bl	3cd4 <tft_DrawPixel>
    	gfx_DrawPixel(x0 + x, y0 - y, color);
    4374:	9b00      	ldr	r3, [sp, #0]
    4376:	4622      	mov	r2, r4
    4378:	ebc3 0b08 	rsb	fp, r3, r8
    437c:	9b03      	ldr	r3, [sp, #12]
    437e:	fa0f fb8b 	sxth.w	fp, fp
    4382:	4618      	mov	r0, r3
    4384:	4659      	mov	r1, fp
    4386:	f7ff fca5 	bl	3cd4 <tft_DrawPixel>
    	gfx_DrawPixel(x0 - x, y0 - y, color);
    438a:	4622      	mov	r2, r4
    438c:	4659      	mov	r1, fp
    438e:	4650      	mov	r0, sl
    4390:	f7ff fca0 	bl	3cd4 <tft_DrawPixel>
    	gfx_DrawPixel(x0 + y, y0 + x, color);
    4394:	9b00      	ldr	r3, [sp, #0]
    4396:	4622      	mov	r2, r4
    4398:	eb05 0a03 	add.w	sl, r5, r3
    439c:	9b01      	ldr	r3, [sp, #4]
    439e:	fa0f fa8a 	sxth.w	sl, sl
    43a2:	eb08 0b03 	add.w	fp, r8, r3
    43a6:	fa0f fb8b 	sxth.w	fp, fp
    43aa:	4659      	mov	r1, fp
    43ac:	4650      	mov	r0, sl
    43ae:	f7ff fc91 	bl	3cd4 <tft_DrawPixel>
    	gfx_DrawPixel(x0 - y, y0 + x, color);
    43b2:	9b00      	ldr	r3, [sp, #0]
    43b4:	4622      	mov	r2, r4
    43b6:	1aeb      	subs	r3, r5, r3
    43b8:	b21b      	sxth	r3, r3
    43ba:	4659      	mov	r1, fp
    43bc:	4618      	mov	r0, r3
    43be:	9300      	str	r3, [sp, #0]
    43c0:	f7ff fc88 	bl	3cd4 <tft_DrawPixel>
    43c4:	9b01      	ldr	r3, [sp, #4]
    	gfx_DrawPixel(x0 + y, y0 - x, color);
    43c6:	4622      	mov	r2, r4
    43c8:	ebc3 0b08 	rsb	fp, r3, r8
    43cc:	fa0f fb8b 	sxth.w	fp, fp
    43d0:	4659      	mov	r1, fp
    43d2:	4650      	mov	r0, sl
    43d4:	f7ff fc7e 	bl	3cd4 <tft_DrawPixel>
    	gfx_DrawPixel(x0 - y, y0 - x, color);
    43d8:	9b00      	ldr	r3, [sp, #0]
      		ddF_y += 2;
      		f += ddF_y;
    	}
    	x++;
    	ddF_x += 2;
    	f += ddF_x;
    43da:	eb07 0749 	add.w	r7, r7, r9, lsl #1
    	gfx_DrawPixel(x0 + x, y0 - y, color);
    	gfx_DrawPixel(x0 - x, y0 - y, color);
    	gfx_DrawPixel(x0 + y, y0 + x, color);
    	gfx_DrawPixel(x0 - y, y0 + x, color);
    	gfx_DrawPixel(x0 + y, y0 - x, color);
    	gfx_DrawPixel(x0 - y, y0 - x, color);
    43de:	4622      	mov	r2, r4
    43e0:	4659      	mov	r1, fp
    43e2:	4618      	mov	r0, r3
      		ddF_y += 2;
      		f += ddF_y;
    	}
    	x++;
    	ddF_x += 2;
    	f += ddF_x;
    43e4:	3701      	adds	r7, #1
    	gfx_DrawPixel(x0 + x, y0 - y, color);
    	gfx_DrawPixel(x0 - x, y0 - y, color);
    	gfx_DrawPixel(x0 + y, y0 + x, color);
    	gfx_DrawPixel(x0 - y, y0 + x, color);
    	gfx_DrawPixel(x0 + y, y0 - x, color);
    	gfx_DrawPixel(x0 - y, y0 - x, color);
    43e6:	f7ff fc75 	bl	3cd4 <tft_DrawPixel>
    43ea:	e79d      	b.n	4328 <gfx_DrawCircle+0x68>
  	}
}
    43ec:	b005      	add	sp, #20
    43ee:	e8bd 8ff0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}

Disassembly of section .text.gfx_DrawCircleHelper:

000043f2 <gfx_DrawCircleHelper>:

void gfx_DrawCircleHelper( int x0, int y0, int r, uint cornername, uint color) {
    43f2:	e92d 4ff0 	stmdb	sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
    43f6:	469b      	mov	fp, r3
    43f8:	4614      	mov	r4, r2
  	int f     = 1 - r;
  	int ddF_x = 1;
  	int ddF_y = -2 * r;
    43fa:	f06f 0301 	mvn.w	r3, #1
    43fe:	4353      	muls	r3, r2
    	gfx_DrawPixel(x0 + y, y0 - x, color);
    	gfx_DrawPixel(x0 - y, y0 - x, color);
  	}
}

void gfx_DrawCircleHelper( int x0, int y0, int r, uint cornername, uint color) {
    4400:	b085      	sub	sp, #20
  	int f     = 1 - r;
  	int ddF_x = 1;
  	int ddF_y = -2 * r;
    4402:	9301      	str	r3, [sp, #4]
      		f     += ddF_y;
    	}
    	x++;
    	ddF_x += 2;
    	f     += ddF_x;
    	if (cornername & 0x4) {
    4404:	f00b 0304 	and.w	r3, fp, #4
    	gfx_DrawPixel(x0 - y, y0 - x, color);
  	}
}

void gfx_DrawCircleHelper( int x0, int y0, int r, uint cornername, uint color) {
  	int f     = 1 - r;
    4408:	f1c2 0801 	rsb	r8, r2, #1
  	int ddF_x = 1;
  	int ddF_y = -2 * r;
  	int x     = 0;
    440c:	2500      	movs	r5, #0
      		f     += ddF_y;
    	}
    	x++;
    	ddF_x += 2;
    	f     += ddF_x;
    	if (cornername & 0x4) {
    440e:	9302      	str	r3, [sp, #8]
      		gfx_DrawPixel(x0 + x, y0 + y, color);
    4410:	b286      	uxth	r6, r0
    4412:	b28f      	uxth	r7, r1
  	int ddF_x = 1;
  	int ddF_y = -2 * r;
  	int x     = 0;
  	int y     = r;

  	while (x<y) {
    4414:	42a5      	cmp	r5, r4
    4416:	f280 8081 	bge.w	451c <gfx_DrawCircleHelper+0x12a>
    	if (f >= 0) {
    441a:	f1b8 0f00 	cmp.w	r8, #0
    441e:	db04      	blt.n	442a <gfx_DrawCircleHelper+0x38>
      		y--;
      		ddF_y += 2;
    4420:	9b01      	ldr	r3, [sp, #4]
  	int x     = 0;
  	int y     = r;

  	while (x<y) {
    	if (f >= 0) {
      		y--;
    4422:	3c01      	subs	r4, #1
      		ddF_y += 2;
    4424:	3302      	adds	r3, #2
    4426:	9301      	str	r3, [sp, #4]
      		f     += ddF_y;
    4428:	4498      	add	r8, r3
    	}
    	x++;
    442a:	3501      	adds	r5, #1
    	ddF_x += 2;
    	f     += ddF_x;
    	if (cornername & 0x4) {
    442c:	9b02      	ldr	r3, [sp, #8]
      		ddF_y += 2;
      		f     += ddF_y;
    	}
    	x++;
    	ddF_x += 2;
    	f     += ddF_x;
    442e:	eb08 0845 	add.w	r8, r8, r5, lsl #1
    4432:	f108 0801 	add.w	r8, r8, #1
    	if (cornername & 0x4) {
    4436:	b1cb      	cbz	r3, 446c <gfx_DrawCircleHelper+0x7a>
      		gfx_DrawPixel(x0 + x, y0 + y, color);
    4438:	f8bd 3038 	ldrh.w	r3, [sp, #56]	; 0x38
    443c:	fa1f fa85 	uxth.w	sl, r5
    4440:	fa1f f984 	uxth.w	r9, r4
    4444:	eb07 0109 	add.w	r1, r7, r9
    4448:	eb06 000a 	add.w	r0, r6, sl
    444c:	461a      	mov	r2, r3
    444e:	b209      	sxth	r1, r1
    4450:	b200      	sxth	r0, r0
    4452:	9303      	str	r3, [sp, #12]
    4454:	f7ff fc3e 	bl	3cd4 <tft_DrawPixel>
      		gfx_DrawPixel(x0 + y, y0 + x, color);
    4458:	9b03      	ldr	r3, [sp, #12]
    445a:	eb07 010a 	add.w	r1, r7, sl
    445e:	eb06 0009 	add.w	r0, r6, r9
    4462:	461a      	mov	r2, r3
    4464:	b209      	sxth	r1, r1
    4466:	b200      	sxth	r0, r0
    4468:	f7ff fc34 	bl	3cd4 <tft_DrawPixel>
    	}
    	if (cornername & 0x2) {
    446c:	f01b 0f02 	tst.w	fp, #2
    4470:	d019      	beq.n	44a6 <gfx_DrawCircleHelper+0xb4>
      		gfx_DrawPixel(x0 + x, y0 - y, color);
    4472:	f8bd 3038 	ldrh.w	r3, [sp, #56]	; 0x38
    4476:	fa1f fa85 	uxth.w	sl, r5
    447a:	fa1f f984 	uxth.w	r9, r4
    447e:	ebc9 0107 	rsb	r1, r9, r7
    4482:	eb06 000a 	add.w	r0, r6, sl
    4486:	461a      	mov	r2, r3
    4488:	b209      	sxth	r1, r1
    448a:	b200      	sxth	r0, r0
    448c:	9303      	str	r3, [sp, #12]
    448e:	f7ff fc21 	bl	3cd4 <tft_DrawPixel>
      		gfx_DrawPixel(x0 + y, y0 - x, color);
    4492:	9b03      	ldr	r3, [sp, #12]
    4494:	ebca 0107 	rsb	r1, sl, r7
    4498:	eb06 0009 	add.w	r0, r6, r9
    449c:	461a      	mov	r2, r3
    449e:	b209      	sxth	r1, r1
    44a0:	b200      	sxth	r0, r0
    44a2:	f7ff fc17 	bl	3cd4 <tft_DrawPixel>
    	}
    	if (cornername & 0x8) {
    44a6:	f01b 0f08 	tst.w	fp, #8
    44aa:	d019      	beq.n	44e0 <gfx_DrawCircleHelper+0xee>
      		gfx_DrawPixel(x0 - y, y0 + x, color);
    44ac:	f8bd 3038 	ldrh.w	r3, [sp, #56]	; 0x38
    44b0:	fa1f fa84 	uxth.w	sl, r4
    44b4:	fa1f f985 	uxth.w	r9, r5
    44b8:	eb07 0109 	add.w	r1, r7, r9
    44bc:	ebca 0006 	rsb	r0, sl, r6
    44c0:	461a      	mov	r2, r3
    44c2:	b209      	sxth	r1, r1
    44c4:	b200      	sxth	r0, r0
    44c6:	9303      	str	r3, [sp, #12]
    44c8:	f7ff fc04 	bl	3cd4 <tft_DrawPixel>
      		gfx_DrawPixel(x0 - x, y0 + y, color);
    44cc:	9b03      	ldr	r3, [sp, #12]
    44ce:	eb0a 0107 	add.w	r1, sl, r7
    44d2:	ebc9 0006 	rsb	r0, r9, r6
    44d6:	461a      	mov	r2, r3
    44d8:	b209      	sxth	r1, r1
    44da:	b200      	sxth	r0, r0
    44dc:	f7ff fbfa 	bl	3cd4 <tft_DrawPixel>
    	}
    	if (cornername & 0x1) {
    44e0:	f01b 0f01 	tst.w	fp, #1
    44e4:	d096      	beq.n	4414 <gfx_DrawCircleHelper+0x22>
      		gfx_DrawPixel(x0 - y, y0 - x, color);
    44e6:	f8bd 3038 	ldrh.w	r3, [sp, #56]	; 0x38
    44ea:	fa1f fa84 	uxth.w	sl, r4
    44ee:	fa1f f985 	uxth.w	r9, r5
    44f2:	ebc9 0107 	rsb	r1, r9, r7
    44f6:	ebca 0006 	rsb	r0, sl, r6
    44fa:	461a      	mov	r2, r3
    44fc:	b209      	sxth	r1, r1
    44fe:	b200      	sxth	r0, r0
    4500:	9303      	str	r3, [sp, #12]
    4502:	f7ff fbe7 	bl	3cd4 <tft_DrawPixel>
      		gfx_DrawPixel(x0 - x, y0 - y, color);
    4506:	9b03      	ldr	r3, [sp, #12]
    4508:	ebca 0107 	rsb	r1, sl, r7
    450c:	ebc9 0006 	rsb	r0, r9, r6
    4510:	461a      	mov	r2, r3
    4512:	b209      	sxth	r1, r1
    4514:	b200      	sxth	r0, r0
    4516:	f7ff fbdd 	bl	3cd4 <tft_DrawPixel>
    451a:	e77b      	b.n	4414 <gfx_DrawCircleHelper+0x22>
    	}
  	}
}
    451c:	b005      	add	sp, #20
    451e:	e8bd 8ff0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}

Disassembly of section .text.gfx_FillCircleHelper:

00004522 <gfx_FillCircleHelper>:

void gfx_FillCircleHelper(int x0, int y0, int r, uint cornername, int delta, uint color) {
    4522:	e92d 4ff0 	stmdb	sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
    4526:	4614      	mov	r4, r2
    4528:	b089      	sub	sp, #36	; 0x24
    452a:	9305      	str	r3, [sp, #20]
  	int f     = 1 - r;
  	int ddF_x = 1;
  	int ddF_y = -2 * r;
    452c:	f06f 0301 	mvn.w	r3, #1
    4530:	4353      	muls	r3, r2
    4532:	9301      	str	r3, [sp, #4]
  	int x     = 0;
    4534:	2300      	movs	r3, #0
    4536:	9300      	str	r3, [sp, #0]
    	}
    	x++;
    	ddF_x += 2;
    	f     += ddF_x;

    	if (cornername & 0x1) {
    4538:	9b05      	ldr	r3, [sp, #20]
  	}
}

void gfx_FillCircleHelper(int x0, int y0, int r, uint cornername, int delta, uint color) {
  	int f     = 1 - r;
  	int ddF_x = 1;
    453a:	f04f 0801 	mov.w	r8, #1
    	}
    	x++;
    	ddF_x += 2;
    	f     += ddF_x;

    	if (cornername & 0x1) {
    453e:	ea03 0308 	and.w	r3, r3, r8
    4542:	9307      	str	r3, [sp, #28]
      		gfx_DrawFastVLine(x0+x, y0-y, 2*y+1+delta, color);
    4544:	f8bd 3048 	ldrh.w	r3, [sp, #72]	; 0x48
      		gfx_DrawPixel(x0 - x, y0 - y, color);
    	}
  	}
}

void gfx_FillCircleHelper(int x0, int y0, int r, uint cornername, int delta, uint color) {
    4548:	9003      	str	r0, [sp, #12]
    	x++;
    	ddF_x += 2;
    	f     += ddF_x;

    	if (cornername & 0x1) {
      		gfx_DrawFastVLine(x0+x, y0-y, 2*y+1+delta, color);
    454a:	9302      	str	r3, [sp, #8]
}

void gfx_DrawFastVLine(s16 x, s16 y, s16 h, uint color) {
  	// Update in subclasses if desired!
  	//gfx_DrawLine(x, y, x, y+h-1, color); // se usar buffer
  	tft_DrawFastVLine(x, y, h, color);
    454c:	4443      	add	r3, r8
      		gfx_DrawPixel(x0 - x, y0 - y, color);
    	}
  	}
}

void gfx_FillCircleHelper(int x0, int y0, int r, uint cornername, int delta, uint color) {
    454e:	9104      	str	r1, [sp, #16]
  	int f     = 1 - r;
    4550:	f1c2 0701 	rsb	r7, r2, #1
}

void gfx_DrawFastVLine(s16 x, s16 y, s16 h, uint color) {
  	// Update in subclasses if desired!
  	//gfx_DrawLine(x, y, x, y+h-1, color); // se usar buffer
  	tft_DrawFastVLine(x, y, h, color);
    4554:	9306      	str	r3, [sp, #24]
  	int ddF_x = 1;
  	int ddF_y = -2 * r;
  	int x     = 0;
  	int y     = r;

  	while (x<y) {
    4556:	9b00      	ldr	r3, [sp, #0]
    4558:	42a3      	cmp	r3, r4
    455a:	da5a      	bge.n	4612 <gfx_FillCircleHelper+0xf0>
    	if (f >= 0) {
    455c:	2f00      	cmp	r7, #0
    455e:	db04      	blt.n	456a <gfx_FillCircleHelper+0x48>
      		y--;
      		ddF_y += 2;
    4560:	9b01      	ldr	r3, [sp, #4]
  	int x     = 0;
  	int y     = r;

  	while (x<y) {
    	if (f >= 0) {
      		y--;
    4562:	3c01      	subs	r4, #1
      		ddF_y += 2;
    4564:	3302      	adds	r3, #2
    4566:	9301      	str	r3, [sp, #4]
      		f     += ddF_y;
    4568:	441f      	add	r7, r3
    	}
    	x++;
    456a:	9b00      	ldr	r3, [sp, #0]
    	ddF_x += 2;
    456c:	f108 0802 	add.w	r8, r8, #2
    	if (f >= 0) {
      		y--;
      		ddF_y += 2;
      		f     += ddF_y;
    	}
    	x++;
    4570:	3301      	adds	r3, #1
    4572:	9300      	str	r3, [sp, #0]
    	ddF_x += 2;
    	f     += ddF_x;

    	if (cornername & 0x1) {
    4574:	9b07      	ldr	r3, [sp, #28]
      		ddF_y += 2;
      		f     += ddF_y;
    	}
    	x++;
    	ddF_x += 2;
    	f     += ddF_x;
    4576:	4447      	add	r7, r8

    	if (cornername & 0x1) {
    4578:	b31b      	cbz	r3, 45c2 <gfx_FillCircleHelper+0xa0>
      		gfx_DrawFastVLine(x0+x, y0-y, 2*y+1+delta, color);
    457a:	f8bd 500c 	ldrh.w	r5, [sp, #12]
    457e:	f8bd a000 	ldrh.w	sl, [sp]
    4582:	f8bd 6010 	ldrh.w	r6, [sp, #16]
}

void gfx_DrawFastVLine(s16 x, s16 y, s16 h, uint color) {
  	// Update in subclasses if desired!
  	//gfx_DrawLine(x, y, x, y+h-1, color); // se usar buffer
  	tft_DrawFastVLine(x, y, h, color);
    4586:	9b06      	ldr	r3, [sp, #24]
    	x++;
    	ddF_x += 2;
    	f     += ddF_x;

    	if (cornername & 0x1) {
      		gfx_DrawFastVLine(x0+x, y0-y, 2*y+1+delta, color);
    4588:	fa1f f984 	uxth.w	r9, r4
}

void gfx_DrawFastVLine(s16 x, s16 y, s16 h, uint color) {
  	// Update in subclasses if desired!
  	//gfx_DrawLine(x, y, x, y+h-1, color); // se usar buffer
  	tft_DrawFastVLine(x, y, h, color);
    458c:	f8bd b04c 	ldrh.w	fp, [sp, #76]	; 0x4c
    4590:	eb03 0249 	add.w	r2, r3, r9, lsl #1
    4594:	ebc9 0106 	rsb	r1, r9, r6
    4598:	eb05 000a 	add.w	r0, r5, sl
    459c:	465b      	mov	r3, fp
    459e:	b212      	sxth	r2, r2
    45a0:	b209      	sxth	r1, r1
    45a2:	b200      	sxth	r0, r0
    45a4:	f7ff fbc4 	bl	3d30 <tft_DrawFastVLine>
    45a8:	9b02      	ldr	r3, [sp, #8]
    45aa:	ebca 0106 	rsb	r1, sl, r6
    45ae:	eb03 0208 	add.w	r2, r3, r8
    45b2:	eb05 0009 	add.w	r0, r5, r9
    45b6:	465b      	mov	r3, fp
    45b8:	b212      	sxth	r2, r2
    45ba:	b209      	sxth	r1, r1
    45bc:	b200      	sxth	r0, r0
    45be:	f7ff fbb7 	bl	3d30 <tft_DrawFastVLine>

    	if (cornername & 0x1) {
      		gfx_DrawFastVLine(x0+x, y0-y, 2*y+1+delta, color);
      		gfx_DrawFastVLine(x0+y, y0-x, 2*x+1+delta, color);
    	}
    	if (cornername & 0x2) {
    45c2:	9b05      	ldr	r3, [sp, #20]
    45c4:	079b      	lsls	r3, r3, #30
    45c6:	d5c6      	bpl.n	4556 <gfx_FillCircleHelper+0x34>
      		gfx_DrawFastVLine(x0-x, y0-y, 2*y+1+delta, color);
    45c8:	f8bd 500c 	ldrh.w	r5, [sp, #12]
    45cc:	f8bd a000 	ldrh.w	sl, [sp]
    45d0:	f8bd 6010 	ldrh.w	r6, [sp, #16]
}

void gfx_DrawFastVLine(s16 x, s16 y, s16 h, uint color) {
  	// Update in subclasses if desired!
  	//gfx_DrawLine(x, y, x, y+h-1, color); // se usar buffer
  	tft_DrawFastVLine(x, y, h, color);
    45d4:	9b06      	ldr	r3, [sp, #24]
    	if (cornername & 0x1) {
      		gfx_DrawFastVLine(x0+x, y0-y, 2*y+1+delta, color);
      		gfx_DrawFastVLine(x0+y, y0-x, 2*x+1+delta, color);
    	}
    	if (cornername & 0x2) {
      		gfx_DrawFastVLine(x0-x, y0-y, 2*y+1+delta, color);
    45d6:	fa1f f984 	uxth.w	r9, r4
}

void gfx_DrawFastVLine(s16 x, s16 y, s16 h, uint color) {
  	// Update in subclasses if desired!
  	//gfx_DrawLine(x, y, x, y+h-1, color); // se usar buffer
  	tft_DrawFastVLine(x, y, h, color);
    45da:	f8bd b04c 	ldrh.w	fp, [sp, #76]	; 0x4c
    45de:	eb03 0249 	add.w	r2, r3, r9, lsl #1
    45e2:	ebc9 0106 	rsb	r1, r9, r6
    45e6:	ebca 0005 	rsb	r0, sl, r5
    45ea:	465b      	mov	r3, fp
    45ec:	b212      	sxth	r2, r2
    45ee:	b209      	sxth	r1, r1
    45f0:	b200      	sxth	r0, r0
    45f2:	f7ff fb9d 	bl	3d30 <tft_DrawFastVLine>
    45f6:	9b02      	ldr	r3, [sp, #8]
    45f8:	ebca 0106 	rsb	r1, sl, r6
    45fc:	eb03 0208 	add.w	r2, r3, r8
    4600:	ebc9 0005 	rsb	r0, r9, r5
    4604:	465b      	mov	r3, fp
    4606:	b212      	sxth	r2, r2
    4608:	b209      	sxth	r1, r1
    460a:	b200      	sxth	r0, r0
    460c:	f7ff fb90 	bl	3d30 <tft_DrawFastVLine>
    4610:	e7a1      	b.n	4556 <gfx_FillCircleHelper+0x34>
    	if (cornername & 0x2) {
      		gfx_DrawFastVLine(x0-x, y0-y, 2*y+1+delta, color);
      		gfx_DrawFastVLine(x0-y, y0-x, 2*x+1+delta, color);
    	}
  	}
}
    4612:	b009      	add	sp, #36	; 0x24
    4614:	e8bd 8ff0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}

Disassembly of section .text.gfx_FillCircle:

00004618 <gfx_FillCircle>:

void gfx_FillCircle(int x0, int y0, int r, uint color) {
    4618:	b5f7      	push	{r0, r1, r2, r4, r5, r6, r7, lr}
    461a:	460d      	mov	r5, r1
    461c:	4604      	mov	r4, r0
    461e:	4616      	mov	r6, r2
    4620:	461f      	mov	r7, r3
  	gfx_DrawFastVLine(x0, y0-r, 2*r+1, color);
    4622:	b291      	uxth	r1, r2
}

void gfx_DrawFastVLine(s16 x, s16 y, s16 h, uint color) {
  	// Update in subclasses if desired!
  	//gfx_DrawLine(x, y, x, y+h-1, color); // se usar buffer
  	tft_DrawFastVLine(x, y, h, color);
    4624:	004a      	lsls	r2, r1, #1
    4626:	3201      	adds	r2, #1
    4628:	1a69      	subs	r1, r5, r1
    462a:	b29b      	uxth	r3, r3
    462c:	b212      	sxth	r2, r2
    462e:	b209      	sxth	r1, r1
    4630:	b200      	sxth	r0, r0
    4632:	f7ff fb7d 	bl	3d30 <tft_DrawFastVLine>
  	}
}

void gfx_FillCircle(int x0, int y0, int r, uint color) {
  	gfx_DrawFastVLine(x0, y0-r, 2*r+1, color);
  	gfx_FillCircleHelper(x0, y0, r, 3, 0, color);
    4636:	2300      	movs	r3, #0
    4638:	9300      	str	r3, [sp, #0]
    463a:	9701      	str	r7, [sp, #4]
    463c:	2303      	movs	r3, #3
    463e:	4632      	mov	r2, r6
    4640:	4629      	mov	r1, r5
    4642:	4620      	mov	r0, r4
    4644:	f7ff ff6d 	bl	4522 <gfx_FillCircleHelper>
}
    4648:	b003      	add	sp, #12
    464a:	bdf0      	pop	{r4, r5, r6, r7, pc}

Disassembly of section .text.gfx_DrawRoundRect:

0000464c <gfx_DrawRoundRect>:

// Draw a rounded rectangle
void gfx_DrawRoundRect(int x, int y, int w, int h, int r, uint color) {
    464c:	e92d 4ff0 	stmdb	sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
    4650:	4688      	mov	r8, r1
    4652:	4681      	mov	r9, r0
    4654:	b08b      	sub	sp, #44	; 0x2c
    4656:	9c14      	ldr	r4, [sp, #80]	; 0x50
    4658:	9309      	str	r3, [sp, #36]	; 0x24
  	// smarter version
  	gfx_DrawFastHLine(x+r  , y    , w-2*r, color); // Top
    465a:	b2a5      	uxth	r5, r4
    465c:	b283      	uxth	r3, r0
    465e:	9303      	str	r3, [sp, #12]
    4660:	442b      	add	r3, r5
  	gfx_DrawFastVLine(x0, y0-r, 2*r+1, color);
  	gfx_FillCircleHelper(x0, y0, r, 3, 0, color);
}

// Draw a rounded rectangle
void gfx_DrawRoundRect(int x, int y, int w, int h, int r, uint color) {
    4662:	9208      	str	r2, [sp, #32]
  	// smarter version
  	gfx_DrawFastHLine(x+r  , y    , w-2*r, color); // Top
    4664:	b21b      	sxth	r3, r3
    4666:	9304      	str	r3, [sp, #16]
    4668:	f8bd 3020 	ldrh.w	r3, [sp, #32]
    466c:	006e      	lsls	r6, r5, #1
    466e:	9305      	str	r3, [sp, #20]
    4670:	b2b3      	uxth	r3, r6
    4672:	9306      	str	r3, [sp, #24]
    4674:	9a06      	ldr	r2, [sp, #24]
    4676:	9b05      	ldr	r3, [sp, #20]
  	gfx_DrawFastVLine(x0, y0-r, 2*r+1, color);
  	gfx_FillCircleHelper(x0, y0, r, 3, 0, color);
}

// Draw a rounded rectangle
void gfx_DrawRoundRect(int x, int y, int w, int h, int r, uint color) {
    4678:	9f15      	ldr	r7, [sp, #84]	; 0x54
  	// smarter version
  	gfx_DrawFastHLine(x+r  , y    , w-2*r, color); // Top
    467a:	ebc2 0b03 	rsb	fp, r2, r3

void gfx_DrawFastHLine(s16 x, s16 y, s16 w, uint color) {
  	// Update in subclasses if desired!
  	//gfx_DrawLine(x, y, x+w-1, y, color); // se usar buffer

  	tft_DrawFastHLine(x, y, w, color);
    467e:	fa1f fa87 	uxth.w	sl, r7
}

// Draw a rounded rectangle
void gfx_DrawRoundRect(int x, int y, int w, int h, int r, uint color) {
  	// smarter version
  	gfx_DrawFastHLine(x+r  , y    , w-2*r, color); // Top
    4682:	fa0f fb8b 	sxth.w	fp, fp

void gfx_DrawFastHLine(s16 x, s16 y, s16 w, uint color) {
  	// Update in subclasses if desired!
  	//gfx_DrawLine(x, y, x+w-1, y, color); // se usar buffer

  	tft_DrawFastHLine(x, y, w, color);
    4686:	4653      	mov	r3, sl
    4688:	465a      	mov	r2, fp
    468a:	9804      	ldr	r0, [sp, #16]
    468c:	b209      	sxth	r1, r1
    468e:	f7ff fb87 	bl	3da0 <tft_DrawFastHLine>

// Draw a rounded rectangle
void gfx_DrawRoundRect(int x, int y, int w, int h, int r, uint color) {
  	// smarter version
  	gfx_DrawFastHLine(x+r  , y    , w-2*r, color); // Top
  	gfx_DrawFastHLine(x+r  , y+h-1, w-2*r, color); // Bottom
    4692:	f8bd 6024 	ldrh.w	r6, [sp, #36]	; 0x24
    4696:	fa1f f388 	uxth.w	r3, r8

void gfx_DrawFastHLine(s16 x, s16 y, s16 w, uint color) {
  	// Update in subclasses if desired!
  	//gfx_DrawLine(x, y, x+w-1, y, color); // se usar buffer

  	tft_DrawFastHLine(x, y, w, color);
    469a:	1e71      	subs	r1, r6, #1
    469c:	4419      	add	r1, r3

// Draw a rounded rectangle
void gfx_DrawRoundRect(int x, int y, int w, int h, int r, uint color) {
  	// smarter version
  	gfx_DrawFastHLine(x+r  , y    , w-2*r, color); // Top
  	gfx_DrawFastHLine(x+r  , y+h-1, w-2*r, color); // Bottom
    469e:	9307      	str	r3, [sp, #28]

void gfx_DrawFastHLine(s16 x, s16 y, s16 w, uint color) {
  	// Update in subclasses if desired!
  	//gfx_DrawLine(x, y, x+w-1, y, color); // se usar buffer

  	tft_DrawFastHLine(x, y, w, color);
    46a0:	465a      	mov	r2, fp
    46a2:	4653      	mov	r3, sl
    46a4:	9804      	ldr	r0, [sp, #16]
    46a6:	b209      	sxth	r1, r1
    46a8:	f7ff fb7a 	bl	3da0 <tft_DrawFastHLine>
// Draw a rounded rectangle
void gfx_DrawRoundRect(int x, int y, int w, int h, int r, uint color) {
  	// smarter version
  	gfx_DrawFastHLine(x+r  , y    , w-2*r, color); // Top
  	gfx_DrawFastHLine(x+r  , y+h-1, w-2*r, color); // Bottom
  	gfx_DrawFastVLine(x    , y+r  , h-2*r, color); // Left
    46ac:	9b07      	ldr	r3, [sp, #28]
}

void gfx_DrawFastVLine(s16 x, s16 y, s16 h, uint color) {
  	// Update in subclasses if desired!
  	//gfx_DrawLine(x, y, x, y+h-1, color); // se usar buffer
  	tft_DrawFastVLine(x, y, h, color);
    46ae:	fa0f f089 	sxth.w	r0, r9
// Draw a rounded rectangle
void gfx_DrawRoundRect(int x, int y, int w, int h, int r, uint color) {
  	// smarter version
  	gfx_DrawFastHLine(x+r  , y    , w-2*r, color); // Top
  	gfx_DrawFastHLine(x+r  , y+h-1, w-2*r, color); // Bottom
  	gfx_DrawFastVLine(x    , y+r  , h-2*r, color); // Left
    46b2:	441d      	add	r5, r3
    46b4:	9b06      	ldr	r3, [sp, #24]
    46b6:	b22d      	sxth	r5, r5
    46b8:	1af6      	subs	r6, r6, r3
    46ba:	b236      	sxth	r6, r6
}

void gfx_DrawFastVLine(s16 x, s16 y, s16 h, uint color) {
  	// Update in subclasses if desired!
  	//gfx_DrawLine(x, y, x, y+h-1, color); // se usar buffer
  	tft_DrawFastVLine(x, y, h, color);
    46bc:	4653      	mov	r3, sl
    46be:	4632      	mov	r2, r6
    46c0:	4629      	mov	r1, r5
    46c2:	f7ff fb35 	bl	3d30 <tft_DrawFastVLine>
    46c6:	9b05      	ldr	r3, [sp, #20]
    46c8:	4632      	mov	r2, r6
    46ca:	1e58      	subs	r0, r3, #1
    46cc:	9b03      	ldr	r3, [sp, #12]
  	gfx_DrawFastHLine(x+r  , y    , w-2*r, color); // Top
  	gfx_DrawFastHLine(x+r  , y+h-1, w-2*r, color); // Bottom
  	gfx_DrawFastVLine(x    , y+r  , h-2*r, color); // Left
  	gfx_DrawFastVLine(x+w-1, y+r  , h-2*r, color); // Right
  	// draw four corners
  	gfx_DrawCircleHelper(x+r    , y+r    , r, 1, color);
    46ce:	eb04 0608 	add.w	r6, r4, r8
}

void gfx_DrawFastVLine(s16 x, s16 y, s16 h, uint color) {
  	// Update in subclasses if desired!
  	//gfx_DrawLine(x, y, x, y+h-1, color); // se usar buffer
  	tft_DrawFastVLine(x, y, h, color);
    46d2:	4418      	add	r0, r3
    46d4:	4629      	mov	r1, r5
    46d6:	4653      	mov	r3, sl
  	gfx_DrawFastHLine(x+r  , y    , w-2*r, color); // Top
  	gfx_DrawFastHLine(x+r  , y+h-1, w-2*r, color); // Bottom
  	gfx_DrawFastVLine(x    , y+r  , h-2*r, color); // Left
  	gfx_DrawFastVLine(x+w-1, y+r  , h-2*r, color); // Right
  	// draw four corners
  	gfx_DrawCircleHelper(x+r    , y+r    , r, 1, color);
    46d8:	eb09 0504 	add.w	r5, r9, r4
}

void gfx_DrawFastVLine(s16 x, s16 y, s16 h, uint color) {
  	// Update in subclasses if desired!
  	//gfx_DrawLine(x, y, x, y+h-1, color); // se usar buffer
  	tft_DrawFastVLine(x, y, h, color);
    46dc:	b200      	sxth	r0, r0
    46de:	f7ff fb27 	bl	3d30 <tft_DrawFastVLine>
  	gfx_DrawFastHLine(x+r  , y    , w-2*r, color); // Top
  	gfx_DrawFastHLine(x+r  , y+h-1, w-2*r, color); // Bottom
  	gfx_DrawFastVLine(x    , y+r  , h-2*r, color); // Left
  	gfx_DrawFastVLine(x+w-1, y+r  , h-2*r, color); // Right
  	// draw four corners
  	gfx_DrawCircleHelper(x+r    , y+r    , r, 1, color);
    46e2:	4622      	mov	r2, r4
    46e4:	4631      	mov	r1, r6
    46e6:	4628      	mov	r0, r5
    46e8:	9700      	str	r7, [sp, #0]
    46ea:	2301      	movs	r3, #1
    46ec:	f7ff fe81 	bl	43f2 <gfx_DrawCircleHelper>
  	gfx_DrawCircleHelper(x+w-r-1, y+r    , r, 2, color);
    46f0:	9b08      	ldr	r3, [sp, #32]
    46f2:	4622      	mov	r2, r4
    46f4:	4499      	add	r9, r3
    46f6:	ebc4 0909 	rsb	r9, r4, r9
    46fa:	f109 39ff 	add.w	r9, r9, #4294967295
    46fe:	4631      	mov	r1, r6
    4700:	4648      	mov	r0, r9
    4702:	9700      	str	r7, [sp, #0]
    4704:	2302      	movs	r3, #2
    4706:	f7ff fe74 	bl	43f2 <gfx_DrawCircleHelper>
  	gfx_DrawCircleHelper(x+w-r-1, y+h-r-1, r, 4, color);
    470a:	9b09      	ldr	r3, [sp, #36]	; 0x24
    470c:	4622      	mov	r2, r4
    470e:	4498      	add	r8, r3
    4710:	ebc4 0808 	rsb	r8, r4, r8
    4714:	f108 38ff 	add.w	r8, r8, #4294967295
    4718:	4641      	mov	r1, r8
    471a:	4648      	mov	r0, r9
    471c:	9700      	str	r7, [sp, #0]
    471e:	2304      	movs	r3, #4
    4720:	f7ff fe67 	bl	43f2 <gfx_DrawCircleHelper>
  	gfx_DrawCircleHelper(x+r    , y+h-r-1, r, 8, color);
    4724:	4622      	mov	r2, r4
    4726:	4641      	mov	r1, r8
    4728:	4628      	mov	r0, r5
    472a:	2308      	movs	r3, #8
    472c:	9714      	str	r7, [sp, #80]	; 0x50
}
    472e:	b00b      	add	sp, #44	; 0x2c
    4730:	e8bd 4ff0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
  	gfx_DrawFastVLine(x+w-1, y+r  , h-2*r, color); // Right
  	// draw four corners
  	gfx_DrawCircleHelper(x+r    , y+r    , r, 1, color);
  	gfx_DrawCircleHelper(x+w-r-1, y+r    , r, 2, color);
  	gfx_DrawCircleHelper(x+w-r-1, y+h-r-1, r, 4, color);
  	gfx_DrawCircleHelper(x+r    , y+h-r-1, r, 8, color);
    4734:	f7ff be5d 	b.w	43f2 <gfx_DrawCircleHelper>

Disassembly of section .text.gfx_FillRoundRect:

00004738 <gfx_FillRoundRect>:
}

// Fill a rounded rectangle
void gfx_FillRoundRect(int x, int y, int w, int h, int r, uint color) {
    4738:	e92d 4ff7 	stmdb	sp!, {r0, r1, r2, r4, r5, r6, r7, r8, r9, sl, fp, lr}
    473c:	4682      	mov	sl, r0
    473e:	4616      	mov	r6, r2
    4740:	461d      	mov	r5, r3
    4742:	460f      	mov	r7, r1
    4744:	9c0c      	ldr	r4, [sp, #48]	; 0x30
    4746:	f8dd 8034 	ldr.w	r8, [sp, #52]	; 0x34
  	// smarter version
  	gfx_FillRect(x+r, y, w-2*r, h, color);
    474a:	eb00 0904 	add.w	r9, r0, r4
    474e:	ea4f 0b44 	mov.w	fp, r4, lsl #1
    4752:	ebcb 0202 	rsb	r2, fp, r2
    4756:	4648      	mov	r0, r9
    4758:	f8cd 8000 	str.w	r8, [sp]
    475c:	f7ff fc8c 	bl	4078 <gfx_FillRect>

  	// draw four corners
  	gfx_FillCircleHelper(x+w-r-1, y+r, r, 1, h-2*r-1, color);
    4760:	ebcb 0505 	rsb	r5, fp, r5
    4764:	eb0a 0006 	add.w	r0, sl, r6
    4768:	4427      	add	r7, r4
    476a:	3d01      	subs	r5, #1
    476c:	1b00      	subs	r0, r0, r4
    476e:	4622      	mov	r2, r4
    4770:	4639      	mov	r1, r7
    4772:	e88d 0120 	stmia.w	sp, {r5, r8}
    4776:	2301      	movs	r3, #1
    4778:	3801      	subs	r0, #1
    477a:	f7ff fed2 	bl	4522 <gfx_FillCircleHelper>
  	gfx_FillCircleHelper(x+r    , y+r, r, 2, h-2*r-1, color);
    477e:	4622      	mov	r2, r4
    4780:	4639      	mov	r1, r7
    4782:	4648      	mov	r0, r9
    4784:	2302      	movs	r3, #2
    4786:	f8cd 8034 	str.w	r8, [sp, #52]	; 0x34
    478a:	950c      	str	r5, [sp, #48]	; 0x30
}
    478c:	b003      	add	sp, #12
    478e:	e8bd 4ff0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
  	// smarter version
  	gfx_FillRect(x+r, y, w-2*r, h, color);

  	// draw four corners
  	gfx_FillCircleHelper(x+w-r-1, y+r, r, 1, h-2*r-1, color);
  	gfx_FillCircleHelper(x+r    , y+r, r, 2, h-2*r-1, color);
    4792:	f7ff bec6 	b.w	4522 <gfx_FillCircleHelper>

Disassembly of section .text.gfx_SetCursor:

00004798 <gfx_SetCursor>:
//##################################################################################################################
// FONTS
//##################################################################################################################
//#include ""
void gfx_SetCursor(int x, int y) {
  	cursor_x = x;
    4798:	4b02      	ldr	r3, [pc, #8]	; (47a4 <gfx_SetCursor+0xc>)
    479a:	6018      	str	r0, [r3, #0]
  	cursor_y = y;
    479c:	4b02      	ldr	r3, [pc, #8]	; (47a8 <gfx_SetCursor+0x10>)
    479e:	6019      	str	r1, [r3, #0]
    47a0:	4770      	bx	lr
    47a2:	bf00      	nop
    47a4:	10000878 	.word	0x10000878
    47a8:	1000087c 	.word	0x1000087c

Disassembly of section .text.gfx_SetTextSize:

000047ac <gfx_SetTextSize>:
int gfx_GetCursorY(void) {
  	return cursor_y;
}

void gfx_SetTextSize(int s) {
  	textsize = (s > 0) ? s : 1;
    47ac:	2801      	cmp	r0, #1
    47ae:	4b02      	ldr	r3, [pc, #8]	; (47b8 <gfx_SetTextSize+0xc>)
    47b0:	bfb8      	it	lt
    47b2:	2001      	movlt	r0, #1
    47b4:	6018      	str	r0, [r3, #0]
    47b6:	4770      	bx	lr
    47b8:	1000086c 	.word	0x1000086c

Disassembly of section .text.gfx_SetTextColor:

000047bc <gfx_SetTextColor>:
//  // to the same as fg instead of using a flag
//  textcolor = textbgcolor = c;
//}

void gfx_SetTextColor(uint c) {
  	textcolor   = c;
    47bc:	4b01      	ldr	r3, [pc, #4]	; (47c4 <gfx_SetTextColor+0x8>)
    47be:	6018      	str	r0, [r3, #0]
    47c0:	4770      	bx	lr
    47c2:	bf00      	nop
    47c4:	10000864 	.word	0x10000864

Disassembly of section .text.gfx_DrawChar:

000047c8 <gfx_DrawChar>:
   	}
  	return pdPASS;
}

// Draw a character
void gfx_DrawChar(int x, int y, unsigned char c, uint color, uint size) {
    47c8:	e92d 4ff0 	stmdb	sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
    47cc:	b08f      	sub	sp, #60	; 0x3c
    47ce:	9307      	str	r3, [sp, #28]
  	if(!gfxFont) return;
    47d0:	4b3a      	ldr	r3, [pc, #232]	; (48bc <gfx_DrawChar+0xf4>)
   	}
  	return pdPASS;
}

// Draw a character
void gfx_DrawChar(int x, int y, unsigned char c, uint color, uint size) {
    47d2:	9106      	str	r1, [sp, #24]
  	if(!gfxFont) return;
    47d4:	6819      	ldr	r1, [r3, #0]
   	}
  	return pdPASS;
}

// Draw a character
void gfx_DrawChar(int x, int y, unsigned char c, uint color, uint size) {
    47d6:	9005      	str	r0, [sp, #20]
    47d8:	9d18      	ldr	r5, [sp, #96]	; 0x60
  	if(!gfxFont) return;
    47da:	2900      	cmp	r1, #0
    47dc:	d06a      	beq.n	48b4 <gfx_DrawChar+0xec>
    // Character is assumed previously filtered by write() to eliminate
    // newlines, returns, non-printable characters, etc.  Calling drawChar()
    // directly with 'bad' characters of font may cause mayhem!

    c -= gfxFont->first;
	const tGFXglyph* glyph = &gfxFont->glyph[c];
    47de:	688b      	ldr	r3, [r1, #8]
    47e0:	6848      	ldr	r0, [r1, #4]
    47e2:	1ad2      	subs	r2, r2, r3
    47e4:	b2d2      	uxtb	r2, r2
    47e6:	2318      	movs	r3, #24
    47e8:	435a      	muls	r2, r3
    47ea:	1883      	adds	r3, r0, r2
    const u8* bitmap = gfxFont->bitmap;
    uint bo = glyph->bitmapOffset;
    47ec:	f850 b002 	ldr.w	fp, [r0, r2]
    u8  w  = glyph->width,
    47f0:	791a      	ldrb	r2, [r3, #4]
    s8   xo = glyph->xOffset,
         yo = glyph->yOffset;
    u8  xx, yy, bits=0, bit = 0;
    int  xo16=0, yo16=0;

    if(size > 1) {
    47f2:	2d01      	cmp	r5, #1

    c -= gfxFont->first;
	const tGFXglyph* glyph = &gfxFont->glyph[c];
    const u8* bitmap = gfxFont->bitmap;
    uint bo = glyph->bitmapOffset;
    u8  w  = glyph->width,
    47f4:	9202      	str	r2, [sp, #8]
        h  = glyph->height;
    47f6:	7a1a      	ldrb	r2, [r3, #8]

    s8   xo = glyph->xOffset,
         yo = glyph->yOffset;
    u8  xx, yy, bits=0, bit = 0;
    int  xo16=0, yo16=0;
    47f8:	bf98      	it	ls
    47fa:	f04f 0a00 	movls.w	sl, #0
    c -= gfxFont->first;
	const tGFXglyph* glyph = &gfxFont->glyph[c];
    const u8* bitmap = gfxFont->bitmap;
    uint bo = glyph->bitmapOffset;
    u8  w  = glyph->width,
        h  = glyph->height;
    47fe:	9209      	str	r2, [sp, #36]	; 0x24

    s8   xo = glyph->xOffset,
    4800:	f993 2010 	ldrsb.w	r2, [r3, #16]
         yo = glyph->yOffset;
    4804:	f993 3014 	ldrsb.w	r3, [r3, #20]
    u8  xx, yy, bits=0, bit = 0;
    int  xo16=0, yo16=0;

    if(size > 1) {
      	xo16 = xo;
    4808:	bf86      	itte	hi
    480a:	4690      	movhi	r8, r2
      	yo16 = yo;
    480c:	469a      	movhi	sl, r3
        h  = glyph->height;

    s8   xo = glyph->xOffset,
         yo = glyph->yOffset;
    u8  xx, yy, bits=0, bit = 0;
    int  xo16=0, yo16=0;
    480e:	46d0      	movls	r8, sl
    4810:	46d1      	mov	r9, sl
    const u8* bitmap = gfxFont->bitmap;
    uint bo = glyph->bitmapOffset;
    u8  w  = glyph->width,
        h  = glyph->height;

    s8   xo = glyph->xOffset,
    4812:	9203      	str	r2, [sp, #12]
    4814:	fa5f f288 	uxtb.w	r2, r8
    4818:	4254      	negs	r4, r2
    481a:	9204      	str	r2, [sp, #16]
        	if(!(bit++ & 7)) {
          		bits = bitmap[bo++];
        	}
        	if(bits & 0x80) {
          		if(size == 1) {
            		gfx_DrawPixel(x+xo+xx, y+yo+yy, color);
    481c:	9a06      	ldr	r2, [sp, #24]
    // newlines, returns, non-printable characters, etc.  Calling drawChar()
    // directly with 'bad' characters of font may cause mayhem!

    c -= gfxFont->first;
	const tGFXglyph* glyph = &gfxFont->glyph[c];
    const u8* bitmap = gfxFont->bitmap;
    481e:	6809      	ldr	r1, [r1, #0]
        	if(!(bit++ & 7)) {
          		bits = bitmap[bo++];
        	}
        	if(bits & 0x80) {
          		if(size == 1) {
            		gfx_DrawPixel(x+xo+xx, y+yo+yy, color);
    4820:	4413      	add	r3, r2
    4822:	930c      	str	r3, [sp, #48]	; 0x30
    4824:	f8bd 301c 	ldrh.w	r3, [sp, #28]
    // newlines, returns, non-printable characters, etc.  Calling drawChar()
    // directly with 'bad' characters of font may cause mayhem!

    c -= gfxFont->first;
	const tGFXglyph* glyph = &gfxFont->glyph[c];
    const u8* bitmap = gfxFont->bitmap;
    4828:	9108      	str	r1, [sp, #32]
    482a:	b2e4      	uxtb	r4, r4
    u8  w  = glyph->width,
        h  = glyph->height;

    s8   xo = glyph->xOffset,
         yo = glyph->yOffset;
    u8  xx, yy, bits=0, bit = 0;
    482c:	2600      	movs	r6, #0
        	if(!(bit++ & 7)) {
          		bits = bitmap[bo++];
        	}
        	if(bits & 0x80) {
          		if(size == 1) {
            		gfx_DrawPixel(x+xo+xx, y+yo+yy, color);
    482e:	930d      	str	r3, [sp, #52]	; 0x34
    4830:	ebca 0309 	rsb	r3, sl, r9
    // only creates a new set of problems.  Have an idea to work around
    // this (a canvas object type for MCUs that can afford the RAM and
    // displays supporting setAddrWindow() and pushColors()), but haven't
    // implemented this yet.

	for(yy=0; yy<h; yy++) {
    4834:	9a09      	ldr	r2, [sp, #36]	; 0x24
    4836:	b2db      	uxtb	r3, r3
    4838:	429a      	cmp	r2, r3
    483a:	d93b      	bls.n	48b4 <gfx_DrawChar+0xec>
    483c:	4647      	mov	r7, r8
        	}
        	if(bits & 0x80) {
          		if(size == 1) {
            		gfx_DrawPixel(x+xo+xx, y+yo+yy, color);
          		} else {
            		gfx_FillRect(x+(xo16+xx)*size, y+(yo16+yy)*size, size, size, color);
    483e:	9a06      	ldr	r2, [sp, #24]
    4840:	fb09 2205 	mla	r2, r9, r5, r2
    4844:	920a      	str	r2, [sp, #40]	; 0x28
        	if(!(bit++ & 7)) {
          		bits = bitmap[bo++];
        	}
        	if(bits & 0x80) {
          		if(size == 1) {
            		gfx_DrawPixel(x+xo+xx, y+yo+yy, color);
    4846:	9a0c      	ldr	r2, [sp, #48]	; 0x30
    4848:	4413      	add	r3, r2
    484a:	b21b      	sxth	r3, r3
    484c:	930b      	str	r3, [sp, #44]	; 0x2c
    // this (a canvas object type for MCUs that can afford the RAM and
    // displays supporting setAddrWindow() and pushColors()), but haven't
    // implemented this yet.

	for(yy=0; yy<h; yy++) {
      	for(xx=0; xx<w; xx++) {
    484e:	9904      	ldr	r1, [sp, #16]
    4850:	b2fb      	uxtb	r3, r7
    4852:	18e2      	adds	r2, r4, r3
    4854:	1a5b      	subs	r3, r3, r1
    4856:	9902      	ldr	r1, [sp, #8]
    4858:	b2db      	uxtb	r3, r3
    485a:	4299      	cmp	r1, r3
    485c:	b2d2      	uxtb	r2, r2
    485e:	d924      	bls.n	48aa <gfx_DrawChar+0xe2>
        	if(!(bit++ & 7)) {
    4860:	0752      	lsls	r2, r2, #29
          		bits = bitmap[bo++];
    4862:	bf02      	ittt	eq
    4864:	9b08      	ldreq	r3, [sp, #32]
    4866:	f813 600b 	ldrbeq.w	r6, [r3, fp]
    486a:	f10b 0b01 	addeq.w	fp, fp, #1
        	}
        	if(bits & 0x80) {
    486e:	0633      	lsls	r3, r6, #24
    4870:	d517      	bpl.n	48a2 <gfx_DrawChar+0xda>
          		if(size == 1) {
    4872:	2d01      	cmp	r5, #1
    4874:	d10b      	bne.n	488e <gfx_DrawChar+0xc6>
            		gfx_DrawPixel(x+xo+xx, y+yo+yy, color);
    4876:	9a05      	ldr	r2, [sp, #20]
    4878:	9b03      	ldr	r3, [sp, #12]
    487a:	990b      	ldr	r1, [sp, #44]	; 0x2c
    487c:	1898      	adds	r0, r3, r2
    487e:	ebc8 0000 	rsb	r0, r8, r0
    4882:	4438      	add	r0, r7
    4884:	9a0d      	ldr	r2, [sp, #52]	; 0x34
    4886:	b200      	sxth	r0, r0
    4888:	f7ff fa24 	bl	3cd4 <tft_DrawPixel>
    488c:	e009      	b.n	48a2 <gfx_DrawChar+0xda>
          		} else {
            		gfx_FillRect(x+(xo16+xx)*size, y+(yo16+yy)*size, size, size, color);
    488e:	9b07      	ldr	r3, [sp, #28]
    4890:	9805      	ldr	r0, [sp, #20]
    4892:	9300      	str	r3, [sp, #0]
    4894:	462a      	mov	r2, r5
    4896:	462b      	mov	r3, r5
    4898:	990a      	ldr	r1, [sp, #40]	; 0x28
    489a:	fb07 0005 	mla	r0, r7, r5, r0
    489e:	f7ff fbeb 	bl	4078 <gfx_FillRect>
          		}
        	}
        	bits <<= 1;
    48a2:	0076      	lsls	r6, r6, #1
    48a4:	b2f6      	uxtb	r6, r6
    48a6:	3701      	adds	r7, #1
    48a8:	e7d1      	b.n	484e <gfx_DrawChar+0x86>
    48aa:	440c      	add	r4, r1
    48ac:	b2e4      	uxtb	r4, r4
    48ae:	f109 0901 	add.w	r9, r9, #1
    48b2:	e7bd      	b.n	4830 <gfx_DrawChar+0x68>
      	}
    }
}
    48b4:	b00f      	add	sp, #60	; 0x3c
    48b6:	e8bd 8ff0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
    48ba:	bf00      	nop
    48bc:	100005f8 	.word	0x100005f8

Disassembly of section .text.gfx_PutChar:

000048c0 <gfx_PutChar>:
void gfx_cp437(int x) {
  	_cp437 = x;
}

int gfx_PutChar(n16 ch) {
   	if(ch == '\n') {
    48c0:	280a      	cmp	r0, #10
// to this function to use correct CP437 character values in your code.
void gfx_cp437(int x) {
  	_cp437 = x;
}

int gfx_PutChar(n16 ch) {
    48c2:	b5f7      	push	{r0, r1, r2, r4, r5, r6, r7, lr}
   	if(ch == '\n') {
    48c4:	d10d      	bne.n	48e2 <gfx_PutChar+0x22>
   		cursor_x  = 0;
    48c6:	4b26      	ldr	r3, [pc, #152]	; (4960 <gfx_PutChar+0xa0>)
    48c8:	2200      	movs	r2, #0
    48ca:	601a      	str	r2, [r3, #0]
   		cursor_y += (int)textsize * (u8)(gfxFont->yAdvance);
    48cc:	4b25      	ldr	r3, [pc, #148]	; (4964 <gfx_PutChar+0xa4>)
    48ce:	4926      	ldr	r1, [pc, #152]	; (4968 <gfx_PutChar+0xa8>)
    48d0:	681b      	ldr	r3, [r3, #0]
    48d2:	7c1a      	ldrb	r2, [r3, #16]
    48d4:	4b25      	ldr	r3, [pc, #148]	; (496c <gfx_PutChar+0xac>)
    48d6:	6818      	ldr	r0, [r3, #0]
    48d8:	680b      	ldr	r3, [r1, #0]
    48da:	fb00 3302 	mla	r3, r0, r2, r3
    48de:	600b      	str	r3, [r1, #0]
    48e0:	e03b      	b.n	495a <gfx_PutChar+0x9a>
   	} else if(ch != '\r') {
    48e2:	280d      	cmp	r0, #13
    48e4:	d039      	beq.n	495a <gfx_PutChar+0x9a>
   		u8 first = gfxFont->first;
    48e6:	4b1f      	ldr	r3, [pc, #124]	; (4964 <gfx_PutChar+0xa4>)
    48e8:	6819      	ldr	r1, [r3, #0]
    48ea:	688c      	ldr	r4, [r1, #8]
   		if((ch >= first) && (ch <= (u8)(gfxFont->last))) {
    48ec:	b2e3      	uxtb	r3, r4
    48ee:	4298      	cmp	r0, r3
    48f0:	db33      	blt.n	495a <gfx_PutChar+0x9a>
    48f2:	7b0b      	ldrb	r3, [r1, #12]
    48f4:	4298      	cmp	r0, r3
    48f6:	dc30      	bgt.n	495a <gfx_PutChar+0x9a>
      		u8 c2 = ch - gfxFont->first;
    48f8:	b2c2      	uxtb	r2, r0
        	//tGFXglyph* glyph = &gfxFont->glyph[c2];
        	const tGFXglyph* glyph = &gfxFont->glyph[c2];
    48fa:	1b14      	subs	r4, r2, r4
    48fc:	6848      	ldr	r0, [r1, #4]
    48fe:	b2e3      	uxtb	r3, r4
    4900:	2418      	movs	r4, #24
    4902:	fb04 0403 	mla	r4, r4, r3, r0
        	u8 w = glyph->width, h = glyph->height;

        	if((w > 0) && (h > 0)) { // Is there an associated bitmap?
    4906:	7927      	ldrb	r7, [r4, #4]
    4908:	4d15      	ldr	r5, [pc, #84]	; (4960 <gfx_PutChar+0xa0>)
    490a:	4e18      	ldr	r6, [pc, #96]	; (496c <gfx_PutChar+0xac>)
    490c:	b1ff      	cbz	r7, 494e <gfx_PutChar+0x8e>
    490e:	7a23      	ldrb	r3, [r4, #8]
    4910:	b1eb      	cbz	r3, 494e <gfx_PutChar+0x8e>
          		int xo = glyph->xOffset; // sic
          		if(wrap && ((cursor_x + textsize * (xo + w)) >= _width)) {
    4912:	4b17      	ldr	r3, [pc, #92]	; (4970 <gfx_PutChar+0xb0>)
    4914:	4814      	ldr	r0, [pc, #80]	; (4968 <gfx_PutChar+0xa8>)
    4916:	681b      	ldr	r3, [r3, #0]
    4918:	b18b      	cbz	r3, 493e <gfx_PutChar+0x7e>
    491a:	6923      	ldr	r3, [r4, #16]
    491c:	f8d6 e000 	ldr.w	lr, [r6]
    4920:	443b      	add	r3, r7
    4922:	682f      	ldr	r7, [r5, #0]
    4924:	fb0e 7303 	mla	r3, lr, r3, r7
    4928:	4f12      	ldr	r7, [pc, #72]	; (4974 <gfx_PutChar+0xb4>)
    492a:	683f      	ldr	r7, [r7, #0]
    492c:	42bb      	cmp	r3, r7
    492e:	db06      	blt.n	493e <gfx_PutChar+0x7e>
            		// Drawing character would go off right edge; wrap to new line
            		cursor_x  = 0;
    4930:	2300      	movs	r3, #0
    4932:	602b      	str	r3, [r5, #0]
            		cursor_y += (int)textsize * (u8)(gfxFont->yAdvance);
    4934:	7c09      	ldrb	r1, [r1, #16]
    4936:	6803      	ldr	r3, [r0, #0]
    4938:	fb0e 3301 	mla	r3, lr, r1, r3
    493c:	6003      	str	r3, [r0, #0]
          		}
          		gfx_DrawChar(cursor_x, cursor_y, ch, textcolor, textsize);
    493e:	6833      	ldr	r3, [r6, #0]
    4940:	9300      	str	r3, [sp, #0]
    4942:	4b0d      	ldr	r3, [pc, #52]	; (4978 <gfx_PutChar+0xb8>)
    4944:	6801      	ldr	r1, [r0, #0]
    4946:	681b      	ldr	r3, [r3, #0]
    4948:	6828      	ldr	r0, [r5, #0]
    494a:	f7ff ff3d 	bl	47c8 <gfx_DrawChar>
        	}
        	cursor_x += (glyph->xAdvance) * (int)textsize;
    494e:	682b      	ldr	r3, [r5, #0]
    4950:	68e2      	ldr	r2, [r4, #12]
    4952:	6831      	ldr	r1, [r6, #0]
    4954:	fb01 3302 	mla	r3, r1, r2, r3
    4958:	602b      	str	r3, [r5, #0]
      	}
   	}
  	return pdPASS;
}
    495a:	2001      	movs	r0, #1
    495c:	b003      	add	sp, #12
    495e:	bdf0      	pop	{r4, r5, r6, r7, pc}
    4960:	10000878 	.word	0x10000878
    4964:	100005f8 	.word	0x100005f8
    4968:	1000087c 	.word	0x1000087c
    496c:	1000086c 	.word	0x1000086c
    4970:	10000868 	.word	0x10000868
    4974:	10000860 	.word	0x10000860
    4978:	10000864 	.word	0x10000864

Disassembly of section .text.gfx_SetFont:

0000497c <gfx_SetFont>:
//  } else if(gfxFont) { // NULL passed.  Current font struct defined?
//    // Switching from new to classic font behavior.
//    // Move cursor pos up 6 pixels so it's at top-left of char.
//    cursor_y -= 6;
//  }
  	gfxFont = (tGFXfont*)f;
    497c:	4b01      	ldr	r3, [pc, #4]	; (4984 <gfx_SetFont+0x8>)
    497e:	6018      	str	r0, [r3, #0]
    4980:	4770      	bx	lr
    4982:	bf00      	nop
    4984:	100005f8 	.word	0x100005f8

Disassembly of section .text.gfx_printfInit:

00004988 <gfx_printfInit>:

#if (TFT_USE_PRINTF == pdON)
#include "stdio_uc.h"
static uint devicePrintf = 0;
void gfx_printfInit(uint dev) {
	devicePrintf = dev;
    4988:	4b02      	ldr	r3, [pc, #8]	; (4994 <gfx_printfInit+0xc>)
	rprintf_RegisterDev(dev, gfx_PutChar);	// Anexa a função ao printf
    498a:	4903      	ldr	r1, [pc, #12]	; (4998 <gfx_printfInit+0x10>)

#if (TFT_USE_PRINTF == pdON)
#include "stdio_uc.h"
static uint devicePrintf = 0;
void gfx_printfInit(uint dev) {
	devicePrintf = dev;
    498c:	6018      	str	r0, [r3, #0]
	rprintf_RegisterDev(dev, gfx_PutChar);	// Anexa a função ao printf
    498e:	b2c0      	uxtb	r0, r0
    4990:	f7fe ba2c 	b.w	2dec <rprintf_RegisterDev>
    4994:	10000870 	.word	0x10000870
    4998:	000048c1 	.word	0x000048c1

Disassembly of section .text.gfx_printf:

0000499c <gfx_printf>:
}

// faz o mesmo que rprintf, porém acrescenta espaços vazios para preencher toda a linha,
//	apagando os caracteres impressos anteriormente
void gfx_printf(const cpchar fmt, ...) {
    499c:	b40f      	push	{r0, r1, r2, r3}
    499e:	b510      	push	{r4, lr}
    49a0:	b096      	sub	sp, #88	; 0x58
    49a2:	aa18      	add	r2, sp, #96	; 0x60
    49a4:	f852 1b04 	ldr.w	r1, [r2], #4
	string s;
	tPrint output;

	output.device = 0;
    49a8:	2300      	movs	r3, #0
    49aa:	f88d 3014 	strb.w	r3, [sp, #20]
	output.buf = s;					// Sinaliza qual buffer para armazenar a formatação de string. Também sinaliza que é uma formatação de string e não uma impressão em dipositivo
    49ae:	ac06      	add	r4, sp, #24
	output.isSformat = 1;			// Sinaliza que é um sformat
    49b0:	2301      	movs	r3, #1

	va_list args;					// Cria var para captura de argumentos (fmt) no stack da chamada de função
	va_start(args, fmt);			// Captura os argumentos após fmt
	doprint(&output, fmt, args);	// Faz a formatação da string com ftm e args e manda imprimir
    49b2:	a802      	add	r0, sp, #8
	string s;
	tPrint output;

	output.device = 0;
	output.buf = s;					// Sinaliza qual buffer para armazenar a formatação de string. Também sinaliza que é uma formatação de string e não uma impressão em dipositivo
	output.isSformat = 1;			// Sinaliza que é um sformat
    49b4:	f88d 3013 	strb.w	r3, [sp, #19]

	va_list args;					// Cria var para captura de argumentos (fmt) no stack da chamada de função
	va_start(args, fmt);			// Captura os argumentos após fmt
    49b8:	9201      	str	r2, [sp, #4]
void gfx_printf(const cpchar fmt, ...) {
	string s;
	tPrint output;

	output.device = 0;
	output.buf = s;					// Sinaliza qual buffer para armazenar a formatação de string. Também sinaliza que é uma formatação de string e não uma impressão em dipositivo
    49ba:	9402      	str	r4, [sp, #8]
	output.isSformat = 1;			// Sinaliza que é um sformat

	va_list args;					// Cria var para captura de argumentos (fmt) no stack da chamada de função
	va_start(args, fmt);			// Captura os argumentos após fmt
	doprint(&output, fmt, args);	// Faz a formatação da string com ftm e args e manda imprimir
    49bc:	f7fe fa40 	bl	2e40 <doprint>
	va_end(args);					// Desmonta args

	rprintf(devicePrintf, "%s", s);
    49c0:	4b05      	ldr	r3, [pc, #20]	; (49d8 <gfx_printf+0x3c>)
    49c2:	4622      	mov	r2, r4
    49c4:	4905      	ldr	r1, [pc, #20]	; (49dc <gfx_printf+0x40>)
    49c6:	7818      	ldrb	r0, [r3, #0]
    49c8:	f7fe fbfc 	bl	31c4 <rprintf>
}
    49cc:	b016      	add	sp, #88	; 0x58
    49ce:	e8bd 4010 	ldmia.w	sp!, {r4, lr}
    49d2:	b004      	add	sp, #16
    49d4:	4770      	bx	lr
    49d6:	bf00      	nop
    49d8:	10000870 	.word	0x10000870
    49dc:	0000a624 	.word	0x0000a624

Disassembly of section .text.__get_current_locale:

000049e0 <__get_current_locale>:
    49e0:	4a03      	ldr	r2, [pc, #12]	; (49f0 <__get_current_locale+0x10>)
    49e2:	4b04      	ldr	r3, [pc, #16]	; (49f4 <__get_current_locale+0x14>)
    49e4:	6812      	ldr	r2, [r2, #0]
    49e6:	6b50      	ldr	r0, [r2, #52]	; 0x34
    49e8:	2800      	cmp	r0, #0
    49ea:	bf08      	it	eq
    49ec:	4618      	moveq	r0, r3
    49ee:	4770      	bx	lr
    49f0:	100005d8 	.word	0x100005d8
    49f4:	10000044 	.word	0x10000044

Disassembly of section .text.__locale_ctype_ptr:

000049f8 <__locale_ctype_ptr>:
    49f8:	b508      	push	{r3, lr}
    49fa:	4b03      	ldr	r3, [pc, #12]	; (4a08 <__locale_ctype_ptr+0x10>)
    49fc:	6818      	ldr	r0, [r3, #0]
    49fe:	f7ff ffef 	bl	49e0 <__get_current_locale>
    4a02:	f8d0 00ec 	ldr.w	r0, [r0, #236]	; 0xec
    4a06:	bd08      	pop	{r3, pc}
    4a08:	100005d8 	.word	0x100005d8

Disassembly of section .text.__ascii_mbtowc:

00004a0c <__ascii_mbtowc>:
    4a0c:	b082      	sub	sp, #8
    4a0e:	b149      	cbz	r1, 4a24 <__ascii_mbtowc+0x18>
    4a10:	b15a      	cbz	r2, 4a2a <__ascii_mbtowc+0x1e>
    4a12:	b16b      	cbz	r3, 4a30 <__ascii_mbtowc+0x24>
    4a14:	7813      	ldrb	r3, [r2, #0]
    4a16:	600b      	str	r3, [r1, #0]
    4a18:	7812      	ldrb	r2, [r2, #0]
    4a1a:	1c10      	adds	r0, r2, #0
    4a1c:	bf18      	it	ne
    4a1e:	2001      	movne	r0, #1
    4a20:	b002      	add	sp, #8
    4a22:	4770      	bx	lr
    4a24:	a901      	add	r1, sp, #4
    4a26:	2a00      	cmp	r2, #0
    4a28:	d1f3      	bne.n	4a12 <__ascii_mbtowc+0x6>
    4a2a:	4610      	mov	r0, r2
    4a2c:	b002      	add	sp, #8
    4a2e:	4770      	bx	lr
    4a30:	f06f 0001 	mvn.w	r0, #1
    4a34:	e7f4      	b.n	4a20 <__ascii_mbtowc+0x14>
    4a36:	bf00      	nop

Disassembly of section .text.memset:

00004a38 <memset>:
    4a38:	b470      	push	{r4, r5, r6}
    4a3a:	0784      	lsls	r4, r0, #30
    4a3c:	d046      	beq.n	4acc <memset+0x94>
    4a3e:	1e54      	subs	r4, r2, #1
    4a40:	2a00      	cmp	r2, #0
    4a42:	d041      	beq.n	4ac8 <memset+0x90>
    4a44:	b2cd      	uxtb	r5, r1
    4a46:	4603      	mov	r3, r0
    4a48:	e002      	b.n	4a50 <memset+0x18>
    4a4a:	1e62      	subs	r2, r4, #1
    4a4c:	b3e4      	cbz	r4, 4ac8 <memset+0x90>
    4a4e:	4614      	mov	r4, r2
    4a50:	f803 5b01 	strb.w	r5, [r3], #1
    4a54:	079a      	lsls	r2, r3, #30
    4a56:	d1f8      	bne.n	4a4a <memset+0x12>
    4a58:	2c03      	cmp	r4, #3
    4a5a:	d92e      	bls.n	4aba <memset+0x82>
    4a5c:	b2cd      	uxtb	r5, r1
    4a5e:	ea45 2505 	orr.w	r5, r5, r5, lsl #8
    4a62:	2c0f      	cmp	r4, #15
    4a64:	ea45 4505 	orr.w	r5, r5, r5, lsl #16
    4a68:	d919      	bls.n	4a9e <memset+0x66>
    4a6a:	4626      	mov	r6, r4
    4a6c:	f103 0210 	add.w	r2, r3, #16
    4a70:	3e10      	subs	r6, #16
    4a72:	2e0f      	cmp	r6, #15
    4a74:	f842 5c10 	str.w	r5, [r2, #-16]
    4a78:	f842 5c0c 	str.w	r5, [r2, #-12]
    4a7c:	f842 5c08 	str.w	r5, [r2, #-8]
    4a80:	f842 5c04 	str.w	r5, [r2, #-4]
    4a84:	f102 0210 	add.w	r2, r2, #16
    4a88:	d8f2      	bhi.n	4a70 <memset+0x38>
    4a8a:	f1a4 0210 	sub.w	r2, r4, #16
    4a8e:	f022 020f 	bic.w	r2, r2, #15
    4a92:	f004 040f 	and.w	r4, r4, #15
    4a96:	3210      	adds	r2, #16
    4a98:	2c03      	cmp	r4, #3
    4a9a:	4413      	add	r3, r2
    4a9c:	d90d      	bls.n	4aba <memset+0x82>
    4a9e:	461e      	mov	r6, r3
    4aa0:	4622      	mov	r2, r4
    4aa2:	3a04      	subs	r2, #4
    4aa4:	2a03      	cmp	r2, #3
    4aa6:	f846 5b04 	str.w	r5, [r6], #4
    4aaa:	d8fa      	bhi.n	4aa2 <memset+0x6a>
    4aac:	1f22      	subs	r2, r4, #4
    4aae:	f022 0203 	bic.w	r2, r2, #3
    4ab2:	3204      	adds	r2, #4
    4ab4:	4413      	add	r3, r2
    4ab6:	f004 0403 	and.w	r4, r4, #3
    4aba:	b12c      	cbz	r4, 4ac8 <memset+0x90>
    4abc:	b2c9      	uxtb	r1, r1
    4abe:	441c      	add	r4, r3
    4ac0:	f803 1b01 	strb.w	r1, [r3], #1
    4ac4:	42a3      	cmp	r3, r4
    4ac6:	d1fb      	bne.n	4ac0 <memset+0x88>
    4ac8:	bc70      	pop	{r4, r5, r6}
    4aca:	4770      	bx	lr
    4acc:	4614      	mov	r4, r2
    4ace:	4603      	mov	r3, r0
    4ad0:	e7c2      	b.n	4a58 <memset+0x20>
    4ad2:	bf00      	nop

Disassembly of section .text.strlen:

00004ad4 <strlen>:
    4ad4:	f020 0103 	bic.w	r1, r0, #3
    4ad8:	f010 0003 	ands.w	r0, r0, #3
    4adc:	f1c0 0000 	rsb	r0, r0, #0
    4ae0:	f851 3b04 	ldr.w	r3, [r1], #4
    4ae4:	f100 0c04 	add.w	ip, r0, #4
    4ae8:	ea4f 0ccc 	mov.w	ip, ip, lsl #3
    4aec:	f06f 0200 	mvn.w	r2, #0
    4af0:	bf1c      	itt	ne
    4af2:	fa22 f20c 	lsrne.w	r2, r2, ip
    4af6:	4313      	orrne	r3, r2
    4af8:	f04f 0c01 	mov.w	ip, #1
    4afc:	ea4c 2c0c 	orr.w	ip, ip, ip, lsl #8
    4b00:	ea4c 4c0c 	orr.w	ip, ip, ip, lsl #16
    4b04:	eba3 020c 	sub.w	r2, r3, ip
    4b08:	ea22 0203 	bic.w	r2, r2, r3
    4b0c:	ea12 12cc 	ands.w	r2, r2, ip, lsl #7
    4b10:	bf04      	itt	eq
    4b12:	f851 3b04 	ldreq.w	r3, [r1], #4
    4b16:	3004      	addeq	r0, #4
    4b18:	d0f4      	beq.n	4b04 <strlen+0x30>
    4b1a:	f1c2 0100 	rsb	r1, r2, #0
    4b1e:	ea02 0201 	and.w	r2, r2, r1
    4b22:	fab2 f282 	clz	r2, r2
    4b26:	f1c2 021f 	rsb	r2, r2, #31
    4b2a:	eb00 00d2 	add.w	r0, r0, r2, lsr #3
    4b2e:	4770      	bx	lr

Disassembly of section .text.__ascii_wctomb:

00004b30 <__ascii_wctomb>:
    4b30:	b121      	cbz	r1, 4b3c <__ascii_wctomb+0xc>
    4b32:	2aff      	cmp	r2, #255	; 0xff
    4b34:	d804      	bhi.n	4b40 <__ascii_wctomb+0x10>
    4b36:	700a      	strb	r2, [r1, #0]
    4b38:	2001      	movs	r0, #1
    4b3a:	4770      	bx	lr
    4b3c:	4608      	mov	r0, r1
    4b3e:	4770      	bx	lr
    4b40:	238a      	movs	r3, #138	; 0x8a
    4b42:	6003      	str	r3, [r0, #0]
    4b44:	f04f 30ff 	mov.w	r0, #4294967295
    4b48:	4770      	bx	lr
    4b4a:	bf00      	nop
